chore: Add changeset sorting. (#188)

Add support for topological sort for changesets.

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Introduce `SortChangeset` in `DataStoreSorter` to topologically sort
change sets (preserving metadata) and add comprehensive unit tests.
> 
> - **Server SDK Internals**:
> - **Changeset sorting**: Add `DataStoreSorter.SortChangeset` to
topologically sort `ChangeSet<ItemDescriptor>` entries by dependencies
and `DataKind` priority (segments before features), preserving selector,
type, and environment ID.
> - **Tests**:
>   - Add unit tests in `DataStoreSorterTest` covering:
>     - Metadata preservation (`Type`, `Selector`, `EnvironmentId`).
> - Ordering of prerequisite flags (`Features`) and `Segments` before
`Features`.
> - Empty changeset handling, multiple `DataKind`s, and deleted items
retention.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
5bd3ec0. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: kinyoklion

pkgs/sdk/server/src/Internal/DataStores/DataStoreSorter.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using LaunchDarkly.Sdk.Server.Internal.Model;
@@ -31,6 +31,26 @@ public static FullDataSet<ItemDescriptor> SortAllCollections(FullDataSet<ItemDes
             }
             return new FullDataSet<ItemDescriptor>(dataOut);
         }
+        
+        /// <summary>
+        /// Sort the data in the changeset in dependency order. If there are any duplicates, then the highest version
+        /// of the duplicate item will be retained.
+        /// </summary>
+        /// <param name="inSet">the changeset to sort</param>
+        /// <returns>a sorted copy of the changeset</returns>
+        public static ChangeSet<ItemDescriptor> SortChangeset(ChangeSet<ItemDescriptor> inSet)
+        {
+            var dataOut = new SortedDictionary<DataKind, KeyedItems<ItemDescriptor>>(
+                PriorityComparer.Instance);
+
+            foreach (var entry in inSet.Data)
+            {
+                var kind = entry.Key;
+                dataOut.Add(kind, new KeyedItems<ItemDescriptor>(SortCollection(kind, entry.Value.Items)));
+            }
+
+            return new ChangeSet<ItemDescriptor>(inSet.Type, inSet.Selector, dataOut, inSet.EnvironmentId);
+        }
 
         private static IEnumerable<KeyValuePair<string, ItemDescriptor>> SortCollection(DataKind kind,
             IEnumerable<KeyValuePair<string, ItemDescriptor>> input)

pkgs/sdk/server/test/Internal/DataStores/DataStoreSorterTest.cs

@@ -1,7 +1,9 @@
-using System;
+using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using LaunchDarkly.Sdk.Server.Internal.Model;
+using LaunchDarkly.Sdk.Server.Subsystems;
 using Xunit;
 
 using static LaunchDarkly.Sdk.Server.Subsystems.DataStoreTypes;
@@ -106,5 +108,202 @@ internal static void VerifyDataSetOrder(FullDataSet<ItemDescriptor> resultData,
                 }
             }
         }
+
+        #region SortChangeset tests
+
+        [Fact]
+        public void SortChangeset_PreservesChangeSetMetadata()
+        {
+            var selector = Selector.Make(42, "test-state");
+            const string environmentId = "test-env";
+            var changeSet = new ChangeSet<ItemDescriptor>(
+                ChangeSetType.Partial,
+                selector,
+                ImmutableList<KeyValuePair<DataKind, KeyedItems<ItemDescriptor>>>.Empty,
+                environmentId
+            );
+
+            var result = DataStoreSorter.SortChangeset(changeSet);
+
+            Assert.Equal(ChangeSetType.Partial, result.Type);
+            Assert.Equal(selector.Version, result.Selector.Version);
+            Assert.Equal(selector.State, result.Selector.State);
+            Assert.Equal(environmentId, result.EnvironmentId);
+        }
+        
+        [Fact]
+        public void SortChangeset_SortsPrerequisiteFlagsFirst()
+        {
+            var flagC = new FeatureFlagBuilder("c").Version(1).Build();
+            var flagE = new FeatureFlagBuilder("e").Version(1).Build();
+            var flagB = new FeatureFlagBuilder("b").Version(1)
+                .Prerequisites(new List<Prerequisite>
+                {
+                    new Prerequisite("c", 0),
+                    new Prerequisite("e", 0)
+                })
+                .Build();
+            var flagA = new FeatureFlagBuilder("a").Version(1)
+                .Prerequisites(new List<Prerequisite>
+                {
+                    new Prerequisite("b", 0),
+                    new Prerequisite("c", 0)
+                })
+                .Build();
+
+            var changeSetData = ImmutableList.Create(
+                new KeyValuePair<DataKind, KeyedItems<ItemDescriptor>>(
+                    DataModel.Features,
+                    new KeyedItems<ItemDescriptor>(ImmutableList.Create(
+                        new KeyValuePair<string, ItemDescriptor>("a", new ItemDescriptor(1, flagA)),
+                        new KeyValuePair<string, ItemDescriptor>("b", new ItemDescriptor(1, flagB)),
+                        new KeyValuePair<string, ItemDescriptor>("c", new ItemDescriptor(1, flagC)),
+                        new KeyValuePair<string, ItemDescriptor>("e", new ItemDescriptor(1, flagE))
+                    ))
+                )
+            );
+
+            var changeSet = new ChangeSet<ItemDescriptor>(
+                ChangeSetType.Partial,
+                Selector.Make(1, "state1"),
+                changeSetData,
+                null
+            );
+
+            var result = DataStoreSorter.SortChangeset(changeSet);
+
+            var flagsData = result.Data.First(kv => kv.Key == DataModel.Features);
+            var resultKeys = flagsData.Value.Items.Select(kv => kv.Key).ToList();
+
+            // Verify ordering constraints
+            Assert.True(resultKeys.IndexOf("c") < resultKeys.IndexOf("b"), "c should come before b");
+            Assert.True(resultKeys.IndexOf("e") < resultKeys.IndexOf("b"), "e should come before b");
+            Assert.True(resultKeys.IndexOf("b") < resultKeys.IndexOf("a"), "b should come before a");
+            Assert.True(resultKeys.IndexOf("c") < resultKeys.IndexOf("a"), "c should come before a");
+        }
+
+        [Fact]
+        public void SortChangeset_SortsSegmentsBeforeFlags()
+        {
+            var flag1 = new FeatureFlagBuilder("flag1").Version(1).Build();
+            var segment1 = new SegmentBuilder("seg1").Version(1).Build();
+
+            var changeSetData = ImmutableList.Create(
+                new KeyValuePair<DataKind, KeyedItems<ItemDescriptor>>(
+                    DataModel.Features,
+                    new KeyedItems<ItemDescriptor>(ImmutableList.Create(
+                        new KeyValuePair<string, ItemDescriptor>("flag1", new ItemDescriptor(1, flag1))
+                    ))
+                ),
+                new KeyValuePair<DataKind, KeyedItems<ItemDescriptor>>(
+                    DataModel.Segments,
+                    new KeyedItems<ItemDescriptor>(ImmutableList.Create(
+                        new KeyValuePair<string, ItemDescriptor>("seg1", new ItemDescriptor(1, segment1))
+                    ))
+                )
+            );
+
+            var changeSet = new ChangeSet<ItemDescriptor>(
+                ChangeSetType.Full,
+                Selector.Make(1, "state1"),
+                changeSetData,
+                null
+            );
+
+            var result = DataStoreSorter.SortChangeset(changeSet);
+
+            var kinds = result.Data.Select(kv => kv.Key).ToList();
+            Assert.Equal(2, kinds.Count);
+            Assert.Equal(DataModel.Segments, kinds[0]);
+            Assert.Equal(DataModel.Features, kinds[1]);
+        }
+
+        [Fact]
+        public void SortChangeset_HandlesEmptyChangeset()
+        {
+            var changeSet = new ChangeSet<ItemDescriptor>(
+                ChangeSetType.Full,
+                Selector.Make(1, "state1"),
+                ImmutableList<KeyValuePair<DataKind, KeyedItems<ItemDescriptor>>>.Empty,
+                null
+            );
+
+            var result = DataStoreSorter.SortChangeset(changeSet);
+
+            Assert.Empty(result.Data);
+            Assert.Equal(ChangeSetType.Full, result.Type);
+        }
+
+        [Fact]
+        public void SortChangeset_HandlesMultipleDataKinds()
+        {
+            var flag1 = new FeatureFlagBuilder("flag1").Version(1).Build();
+            var segment1 = new SegmentBuilder("seg1").Version(1).Build();
+            var segment2 = new SegmentBuilder("seg2").Version(2).Build();
+
+            var changeSetData = ImmutableList.Create(
+                new KeyValuePair<DataKind, KeyedItems<ItemDescriptor>>(
+                    DataModel.Features,
+                    new KeyedItems<ItemDescriptor>(ImmutableList.Create(
+                        new KeyValuePair<string, ItemDescriptor>("flag1", new ItemDescriptor(1, flag1))
+                    ))
+                ),
+                new KeyValuePair<DataKind, KeyedItems<ItemDescriptor>>(
+                    DataModel.Segments,
+                    new KeyedItems<ItemDescriptor>(ImmutableList.Create(
+                        new KeyValuePair<string, ItemDescriptor>("seg1", new ItemDescriptor(1, segment1)),
+                        new KeyValuePair<string, ItemDescriptor>("seg2", new ItemDescriptor(2, segment2))
+                    ))
+                )
+            );
+
+            var changeSet = new ChangeSet<ItemDescriptor>(
+                ChangeSetType.Partial,
+                Selector.Make(1, "state1"),
+                changeSetData,
+                null
+            );
+
+            var result = DataStoreSorter.SortChangeset(changeSet);
+
+            Assert.Equal(2, result.Data.Count());
+
+            var segments = result.Data.First(kv => kv.Key == DataModel.Segments);
+            Assert.Equal(2, segments.Value.Items.Count());
+
+            var flags = result.Data.First(kv => kv.Key == DataModel.Features);
+            Assert.Single(flags.Value.Items);
+        }
+
+        [Fact]
+        public void SortChangeset_PreservesDeletedItems()
+        {
+            var changeSetData = ImmutableList.Create(
+                new KeyValuePair<DataKind, KeyedItems<ItemDescriptor>>(
+                    DataModel.Features,
+                    new KeyedItems<ItemDescriptor>(ImmutableList.Create(
+                        new KeyValuePair<string, ItemDescriptor>("flag1", ItemDescriptor.Deleted(5))
+                    ))
+                )
+            );
+
+            var changeSet = new ChangeSet<ItemDescriptor>(
+                ChangeSetType.Partial,
+                Selector.Make(1, "state1"),
+                changeSetData,
+                null
+            );
+
+            var result = DataStoreSorter.SortChangeset(changeSet);
+
+            var flagsData = result.Data.First(kv => kv.Key == DataModel.Features);
+            var item = flagsData.Value.Items.First();
+
+            Assert.Equal("flag1", item.Key);
+            Assert.Null(item.Value.Item);
+            Assert.Equal(5, item.Value.Version);
+        }
+
+        #endregion
     }
 }