feat(Client)!: Integrate SDK with context-based engine

.gitmodules

@@ -1,4 +1,4 @@
 [submodule "Flagsmith.EngineTest/EngineTestData"]
 	path = Flagsmith.EngineTest/EngineTestData
 	url = git@github.com:Flagsmith/engine-test-data.git
-	tag = v1.0.0
+	tag = v3.4.2

Flagsmith.Client.Test/Fixtures.cs

@@ -13,6 +13,7 @@ internal class Fixtures
         public static AnalyticsProcessorTest GetAnalyticalProcessorTest() => new(new HttpClient(), ApiKey, ApiUrl);
         public static JObject JsonObject = JObject.Parse(@"{
   'api_key': 'test_key',
+  'name': 'Test Environment',
   'project': {
     'name': 'Test project',
     'organisation': {
@@ -56,14 +57,84 @@ internal class Fixtures
       'multivariate_feature_state_values': [],
       'feature_state_value': 'some-value',
       'id': 1,
-      'featurestate_uuid': '40eb539d-3713-4720-bbd4-829dbef10d51',
+      'featurestate_uuid': '00000000-0000-0000-0000-000000000000',
       'feature': {
         'name': 'some_feature',
         'type': 'STANDARD',
         'id': 1
       },
       'segment_id': null,
       'enabled': true
+    },
+    {
+      'feature_state_value': 'default_value',
+      'django_id': 2,
+      'featurestate_uuid': '11111111-1111-1111-1111-111111111111',
+      'feature': {
+        'name': 'mv_feature_with_ids',
+        'type': 'MULTIVARIATE',
+        'id': 2
+      },
+      'segment_id': null,
+      'enabled': true,
+      'multivariate_feature_state_values': [
+        {
+          'id': 100,
+          'multivariate_feature_option': {
+            'id': 10,
+            'value': 'variant_a'
+          },
+          'mv_fs_value_uuid': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa',
+          'percentage_allocation': 30.0
+        },
+        {
+          'id': 200,
+          'multivariate_feature_option': {
+            'id': 20,
+            'value': 'variant_b'
+          },
+          'mv_fs_value_uuid': 'bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb',
+          'percentage_allocation': 70.0
+        }
+      ]
+    },
+    {
+      'feature_state_value': 'fallback_value',
+      'django_id': 3,
+      'featurestate_uuid': '22222222-2222-2222-2222-222222222222',
+      'feature': {
+        'name': 'mv_feature_without_ids',
+        'type': 'MULTIVARIATE',
+        'id': 3
+      },
+      'segment_id': null,
+      'enabled': false,
+      'multivariate_feature_state_values': [
+        {
+          'multivariate_feature_option': {
+            'id': 40,
+            'value': 'option_y'
+          },
+          'mv_fs_value_uuid': 'yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy',
+          'percentage_allocation': 50.0
+        },
+        {
+          'multivariate_feature_option': {
+            'id': 30,
+            'value': 'option_x'
+          },
+          'mv_fs_value_uuid': 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx',
+          'percentage_allocation': 25.0
+        },
+        {
+          'multivariate_feature_option': {
+            'id': 50,
+            'value': 'option_z'
+          },
+          'mv_fs_value_uuid': 'zzzzzzzz-zzzz-zzzz-zzzz-zzzzzzzzzzzz',
+          'percentage_allocation': 25.0
+        }
+      ]
     }
   ],
   'identity_overrides': [

Flagsmith.Client.Test/MappersTest.cs

@@ -0,0 +1,132 @@
+using System.Linq;
+using FlagsmithEngine;
+using FlagsmithEngine.Segment;
+using Xunit;
+
+namespace Flagsmith.FlagsmithClientTest
+{
+    public class MappersTest
+    {
+        [Fact]
+        public void MapEnvironmentDocumentToContext_ProducesEvaluationContext()
+        {
+            // Given
+            var environment = Fixtures.Environment;
+
+            // When
+            var context = Mappers.MapEnvironmentDocumentToContext(environment);
+
+            // Then
+            Assert.IsType<EvaluationContext<SegmentMetadata, FeatureMetadata>>(context);
+            Assert.Equal("test_key", context.Environment.Key);
+            Assert.Equal("Test Environment", context.Environment.Name);
+            Assert.Null(context.Identity);
+            Assert.Equal(2, context.Segments.Count);
+
+            // Verify API segment
+            Assert.True(context.Segments.ContainsKey("1"));
+            var apiSegment = context.Segments["1"];
+            Assert.Equal("1", apiSegment.Key);
+            Assert.Equal("Test segment", apiSegment.Name);
+            Assert.Single(apiSegment.Rules);
+            Assert.Empty(apiSegment.Overrides);
+            Assert.Equal("api", apiSegment.Metadata.Source);
+            Assert.Equal(1, apiSegment.Metadata.Id);
+
+            // Verify segment rule structure
+            Assert.Equal(TypeEnum.All, apiSegment.Rules[0].Type);
+            Assert.Empty(apiSegment.Rules[0].Conditions);
+            Assert.Single(apiSegment.Rules[0].Rules);
+
+            Assert.Equal(TypeEnum.All, apiSegment.Rules[0].Rules[0].Type);
+            Assert.Single(apiSegment.Rules[0].Rules[0].Conditions);
+            Assert.Empty(apiSegment.Rules[0].Rules[0].Rules);
+
+            Assert.Equal("foo", apiSegment.Rules[0].Rules[0].Conditions[0].Property);
+            Assert.Equal(Operator.Equal, apiSegment.Rules[0].Rules[0].Conditions[0].Operator);
+            Assert.Equal("bar", apiSegment.Rules[0].Rules[0].Conditions[0].Value.String);
+
+            // Verify identity override segment
+            var overrideKey = "42d7556943d3c6f62b310e40f2252ac29203c20f37e9adffd8f12bd084a87b9d";
+            Assert.True(context.Segments.ContainsKey(overrideKey));
+            var overrideSegment = context.Segments[overrideKey];
+            Assert.Equal("", overrideSegment.Key);
+            Assert.Equal("identity_overrides", overrideSegment.Name);
+            Assert.Single(overrideSegment.Rules);
+            Assert.Single(overrideSegment.Overrides);
+
+            Assert.Equal(TypeEnum.All, overrideSegment.Rules[0].Type);
+            Assert.Single(overrideSegment.Rules[0].Conditions);
+            Assert.Empty(overrideSegment.Rules[0].Rules);
+
+            Assert.Equal("$.identity.identifier", overrideSegment.Rules[0].Conditions[0].Property);
+            Assert.Equal(Operator.In, overrideSegment.Rules[0].Conditions[0].Operator);
+            Assert.Equal(new[] { "overridden-id" }, overrideSegment.Rules[0].Conditions[0].Value.StringArray);
+
+            Assert.Equal("", overrideSegment.Overrides[0].Key);
+            Assert.Equal("some_feature", overrideSegment.Overrides[0].Name);
+            Assert.False(overrideSegment.Overrides[0].Enabled);
+            Assert.Equal("some-overridden-value", overrideSegment.Overrides[0].Value);
+            Assert.Equal(Constants.StrongestPriority, overrideSegment.Overrides[0].Priority);
+            Assert.Null(overrideSegment.Overrides[0].Variants);
+            Assert.Equal(1, overrideSegment.Overrides[0].Metadata.Id);
+
+            // Verify features
+            Assert.Equal(3, context.Features.Count);
+            Assert.True(context.Features.ContainsKey("some_feature"));
+            var someFeature = context.Features["some_feature"];
+            Assert.Equal("00000000-0000-0000-0000-000000000000", someFeature.Key);
+            Assert.Equal("some_feature", someFeature.Name);
+            Assert.True(someFeature.Enabled);
+            Assert.Equal("some-value", someFeature.Value);
+            Assert.Null(someFeature.Priority);
+            Assert.Empty(someFeature.Variants);
+            Assert.Equal(1, someFeature.Metadata.Id);
+
+            // Verify multivariate feature with IDs - priority should be based on ID
+            Assert.True(context.Features.ContainsKey("mv_feature_with_ids"));
+            var mvFeatureWithIds = context.Features["mv_feature_with_ids"];
+            Assert.Equal("2", mvFeatureWithIds.Key);
+            Assert.Equal("mv_feature_with_ids", mvFeatureWithIds.Name);
+            Assert.True(mvFeatureWithIds.Enabled);
+            Assert.Equal("default_value", mvFeatureWithIds.Value);
+            Assert.Null(mvFeatureWithIds.Priority);
+            Assert.Equal(2, mvFeatureWithIds.Variants.Length);
+            Assert.Equal(2, mvFeatureWithIds.Metadata.Id);
+
+            // First variant: ID=100, should have priority 100
+            Assert.Equal("variant_a", mvFeatureWithIds.Variants[0].Value);
+            Assert.Equal(30.0, mvFeatureWithIds.Variants[0].Weight);
+            Assert.Equal(100, mvFeatureWithIds.Variants[0].Priority);
+
+            // Second variant: ID=200, should have priority 200
+            Assert.Equal("variant_b", mvFeatureWithIds.Variants[1].Value);
+            Assert.Equal(70.0, mvFeatureWithIds.Variants[1].Weight);
+            Assert.Equal(200, mvFeatureWithIds.Variants[1].Priority);
+
+            // Verify multivariate feature without IDs - priority should be based on UUID position
+            Assert.True(context.Features.ContainsKey("mv_feature_without_ids"));
+            var mvFeatureWithoutIds = context.Features["mv_feature_without_ids"];
+            Assert.Equal("3", mvFeatureWithoutIds.Key);
+            Assert.Equal("mv_feature_without_ids", mvFeatureWithoutIds.Name);
+            Assert.False(mvFeatureWithoutIds.Enabled);
+            Assert.Equal("fallback_value", mvFeatureWithoutIds.Value);
+            Assert.Null(mvFeatureWithoutIds.Priority);
+            Assert.Equal(3, mvFeatureWithoutIds.Variants.Length);
+            Assert.Equal(3, mvFeatureWithoutIds.Metadata.Id);
+
+            // Variants should be ordered by UUID alphabetically
+            Assert.Equal("option_y", mvFeatureWithoutIds.Variants[0].Value);
+            Assert.Equal(50.0, mvFeatureWithoutIds.Variants[0].Weight);
+            Assert.Equal(1, mvFeatureWithoutIds.Variants[0].Priority); // Second in sorted UUID order
+
+            Assert.Equal("option_x", mvFeatureWithoutIds.Variants[1].Value);
+            Assert.Equal(25.0, mvFeatureWithoutIds.Variants[1].Weight);
+            Assert.Equal(0, mvFeatureWithoutIds.Variants[1].Priority); // First in sorted UUID order
+
+            Assert.Equal("option_z", mvFeatureWithoutIds.Variants[2].Value);
+            Assert.Equal(25.0, mvFeatureWithoutIds.Variants[2].Weight);
+            Assert.Equal(2, mvFeatureWithoutIds.Variants[2].Priority); // Third in sorted UUID order
+        }
+    }
+}

Flagsmith.Client.Test/data/offline-environment.json

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

Flagsmith.Engine/Engine.cs

@@ -43,73 +43,5 @@ private EvaluationContext<SegmentMetadataT, FeatureMetadataT> GetEnrichedEvaluat
             }
             return context;
         }
-
-        /// <summary>
-        /// Get a list of feature states for a given environment
-        /// </summary>
-        /// <param name="environmentModel">the environment model object</param>
-        /// <returns>list of feature-state model</returns>
-        public List<FeatureStateModel> GetEnvironmentFeatureStates(EnvironmentModel environmentModel) =>
-            environmentModel.Project.HideDisabledFlags ? environmentModel.FeatureStates.Where(fs => fs.Enabled).ToList() : environmentModel.FeatureStates;
-        /// <summary>
-        /// Get a specific feature state for a given feature_name in a given environment
-        /// </summary>
-        /// <param name="environmentModel">environment model object</param>
-        /// <param name="featureName">name of a feature to get</param>
-        /// <returns>feature-state model</returns>
-        public FeatureStateModel GetEnvironmentFeatureState(EnvironmentModel environmentModel, string featureName)
-        {
-            var featureState = environmentModel.FeatureStates.FirstOrDefault(fs => fs.Feature.Name == featureName);
-            if (featureState != null)
-                return featureState;
-
-            throw new FeatureStateNotFound();
-        }
-        public List<FeatureStateModel> GetIdentityFeatureStates(EnvironmentModel environmentModel, IdentityModel identity, List<TraitModel> overrideTraits)
-        {
-            var featureStates = GetIdentityFeatureStatesMapping(environmentModel, identity, overrideTraits).Values.ToList();
-
-            if (environmentModel.Project.HideDisabledFlags)
-                return featureStates.Where(fs => fs.Enabled).ToList();
-
-            return featureStates;
-        }
-        public FeatureStateModel GetIdentityFeatureState(EnvironmentModel environmentModel, IdentityModel identity, string featureName, List<TraitModel> overrideTraits)
-        {
-            var featureStates = GetIdentityFeatureStatesMapping(environmentModel, identity, overrideTraits);
-            var matchingFeature = featureStates.FirstOrDefault(x => x.Key.Name == featureName);
-
-            if (!matchingFeature.Equals(default(KeyValuePair<FeatureModel, FeatureStateModel>)))
-                return matchingFeature.Value;
-
-            throw new FeatureStateNotFound();
-        }
-
-        public Dictionary<FeatureModel, FeatureStateModel> GetIdentityFeatureStatesMapping(EnvironmentModel environmentModel, IdentityModel identity, List<TraitModel> overrideTraits)
-        {
-            var featureStates = environmentModel.FeatureStates.ToDictionary(key => key.Feature, val => val);
-            var identitySegments = Evaluator.GetIdentitySegments(environmentModel, identity, overrideTraits);
-            foreach (var matchingSegment in identitySegments)
-            {
-                foreach (var featureState in matchingSegment.FeatureStates)
-                {
-                    FeatureModel feature = featureState.Feature;
-                    var existing = featureStates.FirstOrDefault(x => x.Key.Id == feature.Id);
-                    if (!existing.Equals(default) && existing.Value.IsHigherPriority(featureState))
-                    {
-                        continue;
-                    }
-
-                    featureStates[feature] = featureState;
-                }
-                ;
-            }
-            identity.IdentityFeatures?.ForEach(x =>
-            {
-                if (featureStates.ContainsKey(x.Feature))
-                    featureStates[x.Feature] = x;
-            });
-            return featureStates;
-        }
     }
 }

Flagsmith.Engine/Environment/Models/EnvironmentModel.cs

@@ -14,6 +14,10 @@ public class EnvironmentModel
 
         [JsonProperty(PropertyName = "api_key")]
         public string ApiKey { get; set; }
+
+        [JsonProperty(PropertyName = "name")]
+        public string Name { get; set; }
+
         [JsonProperty(PropertyName = "project")]
         public ProjectModel Project { get; set; }
         [JsonProperty(PropertyName = "feature_states")]

Flagsmith.Engine/Interfaces/IEngine.cs

@@ -11,10 +11,5 @@ namespace FlagsmithEngine.Interfaces
     public interface IEngine
     {
         EvaluationResult<SegmentMetadataT, FeatureMetadataT> GetEvaluationResult<SegmentMetadataT, FeatureMetadataT>(EvaluationContext<SegmentMetadataT, FeatureMetadataT> context);
-        List<FeatureStateModel> GetEnvironmentFeatureStates(EnvironmentModel environmentModel);
-        FeatureStateModel GetEnvironmentFeatureState(EnvironmentModel environmentModel, string featureName);
-        List<FeatureStateModel> GetIdentityFeatureStates(EnvironmentModel environmentModel, IdentityModel identity, List<TraitModel> overrideTraits = null);
-        FeatureStateModel GetIdentityFeatureState(EnvironmentModel environmentModel, IdentityModel identity, string featureName, List<TraitModel> overrideTraits);
-        Dictionary<FeatureModel, FeatureStateModel> GetIdentityFeatureStatesMapping(EnvironmentModel environmentModel, IdentityModel identity, List<TraitModel> overrideTraits);
     }
 }

Flagsmith.Engine/Segment/Constants.cs

@@ -6,6 +6,7 @@ namespace FlagsmithEngine.Segment
 {
     public static class Constants
     {
+        public const double StrongestPriority = float.NegativeInfinity;
         public const double WeakestPriority = float.PositiveInfinity;
 
         public const string AllRule = "ALL";

Flagsmith.Engine/Segment/Evaluator.cs

@@ -278,9 +278,6 @@
     {
         public static Hashing Hashing = new Hashing();
 
-        public static List<SegmentModel> GetIdentitySegments(EnvironmentModel environmentModel, IdentityModel identity, List<TraitModel> overrideTraits)
-            => environmentModel.Project.Segments.Where(s => EvaluateIdentityInSegment(identity, s, overrideTraits)).ToList();
-
         public static bool EvaluateIdentityInSegment(IdentityModel identity, SegmentModel segment, List<TraitModel> overrideTraits)
         {
             var traits = overrideTraits?.Any() == true ? overrideTraits : identity.IdentityTraits;
@@ -445,10 +442,10 @@
                 {
                     case Constants.Equal: return traitValueAsVersion == conditionValueAsVersion;
                     case Constants.NotEqual: return traitValueAsVersion != conditionValueAsVersion;
                     case Constants.GreaterThan: return traitValueAsVersion > conditionValueAsVersion;
                     case Constants.GreaterThanInclusive: return traitValueAsVersion >= conditionValueAsVersion;
                     case Constants.LessThan: return traitValueAsVersion < conditionValueAsVersion;
                     case Constants.LessThanInclusive: return traitValueAsVersion <= conditionValueAsVersion;
                     default: throw new ArgumentException("Invalid Operator");
                 }
             }