fix: use the updated schema (#183)

* fix: use the updated schema

* use old evaluation

* make getMatchingSegmentsAndOverrides easier on the eyes

* use string instead of string pointer for reason field

* don't use pointer for metadata

Author: gagantrivedi

flagengine/engine.go

@@ -22,62 +22,67 @@ func getPriorityOrDefault(priority *float64) float64 {
 }
 
 func getMatchingSegmentsAndOverrides(ec *engine_eval.EngineEvaluationContext) ([]engine_eval.SegmentResult, map[string]featureContextWithSegmentName) {
-	segments := []engine_eval.SegmentResult{}
-	segmentFeatureContexts := make(map[string]featureContextWithSegmentName)
+	segmentResults := []engine_eval.SegmentResult{}
+	featureOverrides := make(map[string]featureContextWithSegmentName)
 
-	// Get sorted segment keys for deterministic ordering
-	segmentKeys := make([]string, 0, len(ec.Segments))
-	for key := range ec.Segments {
-		segmentKeys = append(segmentKeys, key)
-	}
-	sort.Strings(segmentKeys)
-
-	// Process segments in sorted order
-	for _, key := range segmentKeys {
-		segmentContext := ec.Segments[key]
+	// Process segments in deterministic order (sorted by key)
+	for _, segmentContext := range getSortedSegments(ec.Segments) {
 		if !engine_eval.IsContextInSegment(ec, &segmentContext) {
 			continue
 		}
 
-		// Add segment to results
-		segments = append(segments, engine_eval.SegmentResult{
-			Key:      segmentContext.Key,
+		// Record matched segment
+		segmentResults = append(segmentResults, engine_eval.SegmentResult{
 			Name:     segmentContext.Name,
 			Metadata: segmentContext.Metadata,
 		})
 
-		// Process segment overrides
-		if segmentContext.Overrides != nil {
-			for i := range segmentContext.Overrides {
-				override := &segmentContext.Overrides[i]
-				featureKey := override.FeatureKey
-
-				// Check if we should update the segment feature context
-				shouldUpdate := false
-				if existing, exists := segmentFeatureContexts[featureKey]; !exists {
-					shouldUpdate = true
-				} else {
-					existingPriority := getPriorityOrDefault(existing.featureContext.Priority)
-					overridePriority := getPriorityOrDefault(override.Priority)
-					if overridePriority < existingPriority {
-						shouldUpdate = true
-					}
-				}
+		// Apply segment's feature overrides (respecting priority)
+		applySegmentOverrides(&segmentContext, featureOverrides)
+	}
 
-				if shouldUpdate {
-					segmentFeatureContexts[featureKey] = featureContextWithSegmentName{
-						featureContext: override,
-						segmentName:    segmentContext.Name,
-					}
-				}
+	return segmentResults, featureOverrides
+}
+
+// getSortedSegments returns segments sorted by their keys for deterministic ordering.
+func getSortedSegments(segments map[string]engine_eval.SegmentContext) []engine_eval.SegmentContext {
+	keys := make([]string, 0, len(segments))
+	for key := range segments {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+
+	sorted := make([]engine_eval.SegmentContext, 0, len(keys))
+	for _, key := range keys {
+		sorted = append(sorted, segments[key])
+	}
+	return sorted
+}
+
+// applySegmentOverrides updates the feature overrides map with this segment's overrides,
+// only replacing existing overrides if the new one has equal or higher priority.
+func applySegmentOverrides(segment *engine_eval.SegmentContext, featureOverrides map[string]featureContextWithSegmentName) {
+	for i := range segment.Overrides {
+		override := &segment.Overrides[i]
+		newPriority := getPriorityOrDefault(override.Priority)
+
+		// Check if we should use this override
+		if existing, exists := featureOverrides[override.Name]; exists {
+			existingPriority := getPriorityOrDefault(existing.featureContext.Priority)
+			if newPriority > existingPriority {
+				continue // Existing override has higher priority
 			}
 		}
-	}
 
-	return segments, segmentFeatureContexts
+		// Use this override (either it's new or has equal/higher priority)
+		featureOverrides[override.Name] = featureContextWithSegmentName{
+			featureContext: override,
+			segmentName:    segment.Name,
+		}
+	}
 }
 
-func getFlagResults(ec *engine_eval.EngineEvaluationContext, segmentFeatureContexts map[string]featureContextWithSegmentName) map[string]*engine_eval.FlagResult {
+func getFlagResults(ec *engine_eval.EngineEvaluationContext, featureOverrides map[string]featureContextWithSegmentName) map[string]*engine_eval.FlagResult {
 	flags := make(map[string]*engine_eval.FlagResult)
 
 	// Get identity key if identity exists
@@ -87,24 +92,20 @@ func getFlagResults(ec *engine_eval.EngineEvaluationContext, segmentFeatureConte
 	}
 
 	if ec.Features != nil {
-		for _, featureContext := range ec.Features {
-			// Check if we have a segment override for this feature
-			if segmentFeatureCtx, exists := segmentFeatureContexts[featureContext.FeatureKey]; exists {
-				// Use segment override
-				fc := segmentFeatureCtx.featureContext
-				reason := fmt.Sprintf("TARGETING_MATCH; segment=%s", segmentFeatureCtx.segmentName)
-				flags[featureContext.Name] = &engine_eval.FlagResult{
-					Enabled:    fc.Enabled,
-					FeatureKey: fc.FeatureKey,
-					Name:       fc.Name,
-					Reason:     &reason,
-					Value:      fc.Value,
-					Metadata:   fc.Metadata,
+		for featureName, featureContext := range ec.Features {
+			// Check if there's an override for this feature
+			if override, ok := featureOverrides[featureName]; ok {
+				flags[featureName] = &engine_eval.FlagResult{
+					Enabled:  override.featureContext.Enabled,
+					Name:     featureName,
+					Reason:   fmt.Sprintf("TARGETING_MATCH; segment=%s", override.segmentName),
+					Value:    override.featureContext.Value,
+					Metadata: override.featureContext.Metadata,
 				}
 			} else {
 				// Use default feature context
-				flagResult := getFlagResultFromFeatureContext(&featureContext, identityKey)
-				flags[featureContext.Name] = &flagResult
+				flagResult := getFlagResultFromFeatureContext(featureName, &featureContext, identityKey)
+				flags[featureName] = &flagResult
 			}
 		}
 	}
@@ -114,20 +115,20 @@ func getFlagResults(ec *engine_eval.EngineEvaluationContext, segmentFeatureConte
 
 // GetEvaluationResult computes flags and matched segments.
 func GetEvaluationResult(ec *engine_eval.EngineEvaluationContext) engine_eval.EvaluationResult {
-	// Process segments
-	segments, segmentFeatureContexts := getMatchingSegmentsAndOverrides(ec)
+	// Process segments and get overrides
+	segmentResults, featureOverrides := getMatchingSegmentsAndOverrides(ec)
 
 	// Get flag results
-	flags := getFlagResults(ec, segmentFeatureContexts)
+	flags := getFlagResults(ec, featureOverrides)
 
 	return engine_eval.EvaluationResult{
 		Flags:    flags,
-		Segments: segments,
+		Segments: segmentResults,
 	}
 }
 
 // getFlagResultFromFeatureContext creates a FlagResult from a FeatureContext.
-func getFlagResultFromFeatureContext(featureContext *engine_eval.FeatureContext, identityKey *string) engine_eval.FlagResult {
+func getFlagResultFromFeatureContext(featureName string, featureContext *engine_eval.FeatureContext, identityKey *string) engine_eval.FlagResult {
 	reason := "DEFAULT"
 	value := featureContext.Value
 
@@ -153,12 +154,11 @@ func getFlagResultFromFeatureContext(featureContext *engine_eval.FeatureContext,
 	}
 
 	flagResult := engine_eval.FlagResult{
-		Enabled:    featureContext.Enabled,
-		FeatureKey: featureContext.FeatureKey,
-		Name:       featureContext.Name,
-		Value:      value,
-		Reason:     &reason,
-		Metadata:   featureContext.Metadata,
+		Enabled:  featureContext.Enabled,
+		Name:     featureName,
+		Value:    value,
+		Reason:   reason,
+		Metadata: featureContext.Metadata,
 	}
 
 	return flagResult

flagengine/engine_eval/context.go

@@ -22,7 +22,7 @@ type EngineEvaluationContext struct {
 //
 // Represents an environment context for feature flag evaluation.
 type EnvironmentContext struct {
-	// An environment's unique identifier.
+	// Unique environment key. May be used for selecting a value for a multivariate feature, or for % split segmentation
 	Key string `json:"key"`
 	// An environment's human-readable name.
 	Name string `json:"name"`
@@ -32,8 +32,6 @@ type EnvironmentContext struct {
 type FeatureContext struct {
 	// Indicates whether the feature is enabled in the environment.
 	Enabled bool `json:"enabled"`
-	// Unique feature identifier.
-	FeatureKey string `json:"feature_key"`
 	// Key used when selecting a value for a multivariate feature. Set to an internal identifier
 	// or a UUID, depending on Flagsmith implementation.
 	Key string `json:"key"`
@@ -49,7 +47,7 @@ type FeatureContext struct {
 	// value for standard features, or multiple values for multivariate features.
 	Variants []FeatureValue `json:"variants,omitempty"`
 	// Metadata about the feature.
-	Metadata *FeatureMetadata `json:"metadata,omitempty"`
+	Metadata FeatureMetadata `json:"metadata,omitempty"`
 }
 
 // Represents a multivariate value for a feature flag.
@@ -133,7 +131,7 @@ type SegmentContext struct {
 	// The name of the segment.
 	Name string `json:"name"`
 	// Metadata about the segment.
-	Metadata *SegmentMetadata `json:"metadata,omitempty"`
+	Metadata SegmentMetadata `json:"metadata,omitempty"`
 	// Feature overrides for the segment.
 	Overrides []FeatureContext `json:"overrides,omitempty"`
 	// Rules that define the segment.

flagengine/engine_eval/evaluator_test.go

@@ -61,7 +61,7 @@ func createSegmentContext(key, name string, rules []engine_eval.SegmentRule) *en
 	return &engine_eval.SegmentContext{
 		Key:  key,
 		Name: name,
-		Metadata: &engine_eval.SegmentMetadata{
+		Metadata: engine_eval.SegmentMetadata{
 			SegmentID: segmentID,
 			Source:    engine_eval.SegmentSourceAPI,
 		},
@@ -514,26 +514,6 @@ func TestGetContextValueIntegration(t *testing.T) {
 		result := engine_eval.IsContextInSegment(evalContext, segmentContext)
 		assert.True(t, result)
 	})
-
-	t.Run("JSONPath environment key works", func(t *testing.T) {
-		evalContext := createEvaluationContext(nil)
-
-		segmentContext := createSegmentContext("test", "test", []engine_eval.SegmentRule{
-			{
-				Type: engine_eval.All,
-				Conditions: []engine_eval.Condition{
-					{
-						Operator: engine_eval.Equal,
-						Property: "$.environment.key",
-						Value:    "test-env",
-					},
-				},
-			},
-		})
-
-		result := engine_eval.IsContextInSegment(evalContext, segmentContext)
-		assert.True(t, result)
-	})
 }
 
 func TestToStringIntegration(t *testing.T) {

flagengine/engine_eval/mappers.go

@@ -86,11 +86,10 @@ func mapFeatureStateToFeatureContext(fs *features.FeatureStateModel) FeatureCont
 	}
 
 	fc := FeatureContext{
-		Enabled:    fs.Enabled,
-		FeatureKey: strconv.Itoa(fs.Feature.ID),
-		Key:        key,
-		Name:       fs.Feature.Name,
-		Metadata: &FeatureMetadata{
+		Enabled: fs.Enabled,
+		Key:     key,
+		Name:    fs.Feature.Name,
+		Metadata: FeatureMetadata{
 			FeatureID: fs.Feature.ID,
 		},
 	}
@@ -116,7 +115,7 @@ func mapSegmentToSegmentContext(s *segments.SegmentModel) SegmentContext {
 	sc := SegmentContext{
 		Key:  strconv.Itoa(s.ID),
 		Name: s.Name,
-		Metadata: &SegmentMetadata{
+		Metadata: SegmentMetadata{
 			SegmentID: s.ID,
 			Source:    SegmentSourceAPI,
 		},
@@ -242,7 +241,7 @@ func mapIdentityOverridesToSegments(identityOverrides []*identities.IdentityMode
 		sc := SegmentContext{
 			Key:  "", // Identity override segments never use % Split operator
 			Name: "identity_overrides",
-			Metadata: &SegmentMetadata{
+			Metadata: SegmentMetadata{
 				Source: SegmentSourceIdentityOverride,
 			},
 			Rules: []SegmentRule{
@@ -264,13 +263,12 @@ func mapIdentityOverridesToSegments(identityOverrides []*identities.IdentityMode
 			priority := math.Inf(-1) // Strongest possible priority
 			featureID := featureNameToID[override.featureName]
 			featureOverride := FeatureContext{
-				Key:        "", // Identity overrides never carry multivariate options
-				FeatureKey: strconv.Itoa(featureID),
-				Name:       override.featureName,
-				Enabled:    override.enabled,
-				Priority:   &priority,
-				Value:      override.featureValue,
-				Metadata: &FeatureMetadata{
+				Key:      "", // Identity overrides never carry multivariate options
+				Name:     override.featureName,
+				Enabled:  override.enabled,
+				Priority: &priority,
+				Value:    override.featureValue,
+				Metadata: FeatureMetadata{
 					FeatureID: featureID,
 				},
 			}
@@ -336,7 +334,7 @@ func MapEvaluationResultSegmentsToSegmentModels(
 
 	for _, segmentResult := range result.Segments {
 		// Only include segments from API source (filter out identity overrides)
-		if segmentResult.Metadata == nil || segmentResult.Metadata.Source != SegmentSourceAPI {
+		if segmentResult.Metadata.Source != SegmentSourceAPI {
 			continue
 		}
 

flagengine/engine_eval/mappers_test.go

@@ -98,9 +98,6 @@ func TestMapEnvironmentDocumentToEvaluationContext(t *testing.T) {
 		if !testFeature.Enabled {
 			t.Error("Expected test-feature to be enabled")
 		}
-		if testFeature.FeatureKey != "1" {
-			t.Errorf("Expected FeatureKey to be '1' (feature ID), got %v", testFeature.FeatureKey)
-		}
 		if testFeature.Name != "test-feature" {
 			t.Errorf("Expected Name to be 'test-feature', got %v", testFeature.Name)
 		}
@@ -174,9 +171,6 @@ func TestMapEnvironmentDocumentToEvaluationContext(t *testing.T) {
 			t.Errorf("Expected 1 override in segment, got %d", len(testSegment.Overrides))
 		} else {
 			override := testSegment.Overrides[0]
-			if override.FeatureKey != "1" {
-				t.Errorf("Expected override feature key to be '1' (feature ID), got %v", override.FeatureKey)
-			}
 			if !override.Enabled {
 				t.Error("Expected segment override to be enabled")
 			}
@@ -386,9 +380,8 @@ func TestMapContextAndIdentityDataToContext(t *testing.T) {
 		},
 		Features: map[string]FeatureContext{
 			"test-feature": {
-				Enabled:    true,
-				FeatureKey: "1",
-				Name:       "test-feature",
+				Enabled: true,
+				Name:    "test-feature",
 			},
 		},
 	}
@@ -527,25 +520,22 @@ func TestMapEvaluationResultSegmentsToSegmentModels(t *testing.T) {
 	result := EvaluationResult{
 		Segments: []SegmentResult{
 			{
-				Key:  "1",
 				Name: "test-segment",
-				Metadata: &SegmentMetadata{
+				Metadata: SegmentMetadata{
 					SegmentID: 1,
 					Source:    SegmentSourceAPI,
 				},
 			},
 			{
-				Key:  "42",
 				Name: "another-segment",
-				Metadata: &SegmentMetadata{
+				Metadata: SegmentMetadata{
 					SegmentID: 42,
 					Source:    SegmentSourceAPI,
 				},
 			},
 			{
-				Key:  "",
 				Name: "identity-override-segment",
-				Metadata: &SegmentMetadata{
+				Metadata: SegmentMetadata{
 					SegmentID: 0,
 					Source:    SegmentSourceIdentityOverride,
 				},
@@ -609,7 +599,6 @@ func TestMapEvaluationResultSegmentsToSegmentModelsInvalidKey(t *testing.T) {
 	result := EvaluationResult{
 		Segments: []SegmentResult{
 			{
-				Key:  "invalid-key",
 				Name: "segment-without-metadata",
 			},
 		},