EF Core 10 follow-ons: RichMultiString null-setter, model and test updates

RichMultiString gains an explicit null-setter so the typed IDictionary<,>
implementation satisfies EF Core 10's stricter property requirements. Entry and
Sense get minor model adjustments. Snapshot/test expectations updated for EF
Core 10 query output changes. FluentAssertions global config pinned to
alpha.5 to avoid the 8.x O(N!) BeEquivalentTo regression in CI.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: myieye

backend/FwLite/LcmCrdt.Tests/MiniLcmApiFixture.cs

@@ -77,7 +77,7 @@ await CrdtProjectsService.InitProjectDb(_crdtDbContext,
             projectData);
         await currentProjectService.RefreshProjectData();
         // CreateProject would also seed morph types — so we need to do it manually here
-        await PreDefinedData.AddPredefinedMorphTypes(_services.ServiceProvider.GetRequiredService<DataModel>(), projectData);
+        await PreDefinedData.AddPredefinedMorphTypes(_services.ServiceProvider.GetRequiredService<DataModel>(), projectData.ClientId);
         if (_seedWs)
         {
             await Api.CreateWritingSystem(new WritingSystem()

backend/FwLite/MiniLcm.Tests/FluentAssertGlobalConfig.cs

@@ -16,6 +16,9 @@ public static void Initialize()
             .ComparingByMembers<RichSpan>()
             .Excluding(m => (m.DeclaringType == typeof(ComplexFormComponent) || m.DeclaringType == typeof(WritingSystem))
                             && (m.Name == nameof(ComplexFormComponent.Id) || m.Name == nameof(ComplexFormComponent.MaybeId)))
+            //Shadow query-rewrite targets — domain state lives on the underlying collection.
+            .Excluding(m => (m.DeclaringType == typeof(Entry) && m.Name == nameof(Entry.PublishInRows))
+                            || (m.DeclaringType == typeof(Sense) && m.Name == nameof(Sense.SemanticDomainRows)))
             );
     }
 }

backend/FwLite/MiniLcm.Tests/RichMultiStringTests.cs

@@ -295,6 +295,43 @@ public void JsonPatchCanAddRichMultiString()
         ms["fr"].Should().BeEquivalentTo(new RichString("test", "fr"));
     }
 
+    //emulates older commits in the sync stream where a RichMultiString value was serialized as a plain string
+    [Fact]
+    public void JsonPatchCanAddRichMultiStringWhenValueIsString()
+    {
+        var ms = new RichMultiString() { { "en", new RichString("existing", "en") } };
+        var patch = new JsonPatchDocument<RichMultiString>();
+        patch.Operations.Add(new Operation<RichMultiString>("add", "/fr", null, "test"));
+        patch.ApplyTo(ms);
+        ms.Should().ContainKey("fr");
+        ms["fr"].Should().BeEquivalentTo(new RichString("test", "fr"));
+    }
+
+    //the original repro for "System.ArgumentException: unable to convert value String to RichString":
+    //a JsonPatchDocument<Entry> patches /Note/en with a raw string value. This routes through
+    //PocoAdapter.TryAdd -> DictionaryPropertyProxy, which used to hand RichMultiString.IDictionary.Add a raw string.
+    [Fact]
+    public void JsonPatchCanAddRichMultiStringPropertyOnEntityWhenValueIsString()
+    {
+        var entry = new Entry();
+        var patch = new JsonPatchDocument<Entry>();
+        patch.Operations.Add(new Operation<Entry>("add", "/Note/en", null, "test"));
+        patch.ApplyTo(entry);
+        entry.Note.Should().ContainKey("en");
+        entry.Note["en"].Should().BeEquivalentTo(new RichString("test", "en"));
+    }
+
+    [Fact]
+    public void JsonPatchCanAddRichMultiStringPropertyOnEntityWithRichStringValue()
+    {
+        var entry = new Entry();
+        var patch = new JsonPatchDocument<Entry>();
+        patch.Add(e => e.Note["en"], new RichString("test", "en"));
+        patch.ApplyTo(entry);
+        entry.Note.Should().ContainKey("en");
+        entry.Note["en"].Should().BeEquivalentTo(new RichString("test", "en"));
+    }
+
     [Fact]
     public void RichSpanEquality_TrueWhenMatching()
     {

backend/FwLite/MiniLcm/Models/Entry.cs

@@ -1,3 +1,8 @@
+using System.ComponentModel;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Text.Json.Serialization;
+using MiniLcm.Attributes;
+
 namespace MiniLcm.Models;
 
 public record Entry : IObjectWithId<Entry>
@@ -29,6 +34,13 @@ public record Entry : IObjectWithId<Entry>
 
     public virtual List<Publication> PublishIn { get; set; } = [];
 
+    //Server-side query rewrite target — LcmCrdt rewrites this to Json.Query(PublishIn) so
+    //filter projections (e.g. PublishInRows.Select(...).Any(...)) translate to json_each() SQL.
+    //Public only because LcmCrdt's filter map provider lives in a different assembly; treat as
+    //internal — don't read it from client code, use PublishIn.
+    [MiniLcmInternal, NotMapped, JsonIgnore, EditorBrowsable(EditorBrowsableState.Never)]
+    public IEnumerable<Publication> PublishInRows => PublishIn;
+
     public const string UnknownHeadword = "(Unknown)";
 
     public string Headword()

backend/FwLite/MiniLcm/Models/RichMultiString.cs

@@ -38,10 +38,9 @@ public RichMultiString Copy()
 
     void IDictionary.Add(object key, object? value)
     {
-        var valStr = value as RichString ??
-                     throw new ArgumentException($"unable to convert value {value?.GetType().Name ?? "null"} to RichString",
-                         nameof(value));
-        Add(WritingSystemId.FromUnknown(key), valStr);
+        var richString = value as RichString ??
+                         throw new ArgumentException($"unable to convert value {value?.GetType().Name ?? "null"} to RichString", nameof(value));
+        Add(WritingSystemId.FromUnknown(key), richString);
     }
 
     public void Add(WritingSystemId key, RichString value)
@@ -70,14 +69,14 @@ public bool Contains(KeyValuePair<WritingSystemId, RichString> item)
         return dictionary.Contains(item);
     }
 
-    public void CopyTo(KeyValuePair<WritingSystemId, RichString>[] array, int arrayIndex)
+    public bool Remove(KeyValuePair<WritingSystemId, RichString> item)
     {
-        dictionary.CopyTo(array, arrayIndex);
+        return dictionary.Remove(item);
     }
 
-    public bool Remove(KeyValuePair<WritingSystemId, RichString> item)
+    public void CopyTo(KeyValuePair<WritingSystemId, RichString>[] array, int arrayIndex)
     {
-        return dictionary.Remove(item);
+        dictionary.CopyTo(array, arrayIndex);
     }
 
     public int Count => dictionary.Count;
@@ -104,12 +103,11 @@ public RichString this[WritingSystemId key]
         get => dictionary.TryGetValue(key, out var value) ? value : new RichString([]);
         set
         {
-            // SystemTextJsonPatch's DictionaryTypedPropertyProxy casts to IDictionary<TKey, TValue?>
-            // and may pass null (e.g. when an empty-string RichString deserialized to null). Treat
-            // that as a remove, mirroring the explicit IDictionary.this[object] setter below.
+            // value will be null if an empty string was deserialized as a RichString (e.g. from a JsonPatch operation
+            // routed through DictionaryTypedPropertyProxy). Mirror the IDictionary.this[object] setter and remove the key.
             if (value is null)
             {
-                dictionary.Remove(key);
+                Remove(key);
                 return;
             }
             value.EnsureWs(key);

backend/FwLite/MiniLcm/Models/Sense.cs

@@ -1,3 +1,5 @@
+using System.ComponentModel;
+using System.ComponentModel.DataAnnotations.Schema;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using MiniLcm.Attributes;
@@ -18,6 +20,10 @@ public class Sense : IObjectWithId<Sense>, IOrderable
     public virtual PartOfSpeech? PartOfSpeech { get; set; } = null;
     public virtual Guid? PartOfSpeechId { get; set; }
     public virtual IList<SemanticDomain> SemanticDomains { get; set; } = [];
+
+    //Server-side query rewrite target — see Entry.PublishInRows.
+    [MiniLcmInternal, NotMapped, JsonIgnore, EditorBrowsable(EditorBrowsableState.Never)]
+    public IEnumerable<SemanticDomain> SemanticDomainRows => SemanticDomains;
     public virtual List<ExampleSentence> ExampleSentences { get; set; } = [];
 
     public Guid[] GetReferences()

backend/LexBoxApi/Services/CrdtCommitService.cs

@@ -1,6 +1,7 @@
 using LexCore.Utils;
 using LexData;
 using LinqToDB;
+using LinqToDB.Async;
 using LinqToDB.Data;
 using LinqToDB.EntityFrameworkCore;
 using LinqToDB.EntityFrameworkCore.Internal;
@@ -15,26 +16,18 @@ public async Task AddCommits(Guid projectId, IAsyncEnumerable<ServerCommit> comm
         await using var transaction = await dbContext.Database.BeginTransactionAsync(token);
         var linqToDbContext = dbContext.CreateLinqToDBContext();
         await using var tmpTable = await linqToDbContext.CreateTempTableAsync<ServerCommit>($"tmp_crdt_commit_import_{projectId}__{Guid.NewGuid()}", cancellationToken: token);
-        await tmpTable.BulkCopyAsync(new BulkCopyOptions{BulkCopyType = BulkCopyType.ProviderSpecific, MaxBatchSize = 10}, commits, token);
+        //Stamp ProjectId while streaming so the merge below can be a plain column-to-column copy.
+        //A projection lambda here would let linq2db v6 wrap our Sql.Expr<...>::jsonb cast in the
+        //EF value-converter (JsonSerializer.Serialize) and fail SQL translation.
+        var stampedCommits = commits.Select(c => { c.ProjectId = projectId; return c; });
+        await tmpTable.BulkCopyAsync(new BulkCopyOptions{BulkCopyType = BulkCopyType.ProviderSpecific, MaxBatchSize = 10}, stampedCommits, token);
 
         var commitsTable = linqToDbContext.GetTable<ServerCommit>();
         await commitsTable
             .Merge()
             .Using(tmpTable)
             .OnTargetKey()
-            .InsertWhenNotMatched(commit => new ServerCommit(commit.Id)
-            {
-                Id = commit.Id,
-                ClientId = commit.ClientId,
-                HybridDateTime = new HybridDateTime(commit.HybridDateTime.DateTime, commit.HybridDateTime.Counter)
-                {
-                    DateTime = commit.HybridDateTime.DateTime, Counter = commit.HybridDateTime.Counter
-                },
-                ProjectId = projectId,
-                Metadata = commit.Metadata,
-                //without this sql cast the value will be treated as text and fail to insert into the jsonb column
-                ChangeEntities = Sql.Expr<List<ChangeEntity<ServerJsonChange>>>($"{commit.ChangeEntities}::jsonb")
-            })
+            .InsertWhenNotMatched()
             .MergeAsync(token);
 
         await transaction.CommitAsync(token);

backend/LexData/DataKernel.cs

@@ -1,7 +1,7 @@
 using LexData.Configuration;
 using LinqToDB;
-using LinqToDB.AspNet.Logging;
 using LinqToDB.EntityFrameworkCore;
+using LinqToDB.Extensions.Logging;
 using LinqToDB.Mapping;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;

backend/LexData/LexData.csproj

@@ -2,8 +2,8 @@
   <ItemGroup>
     <PackageReference Include="AppAny.Quartz.EntityFrameworkCore.Migrations.PostgreSQL" />
     <PackageReference Include="Humanizer.Core" />
-    <PackageReference Include="linq2db.AspNet" />
     <PackageReference Include="linq2db.EntityFrameworkCore" />
+    <PackageReference Include="linq2db.Extensions" />
     <PackageReference Include="Microsoft.EntityFrameworkCore" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Design">
       <PrivateAssets>all</PrivateAssets>

backend/Testing/LexCore/Services/CrdtCommitServiceTests.cs

@@ -66,7 +66,6 @@ public async Task CanQueryOldCommits()
     {
         var projectId = await _lexBoxDbContext.Projects.Select(p => p.Id).FirstOrDefaultAsync();
         var context = _lexBoxDbContext.CreateLinqToDBContext();
-        var table = LinqToDB.DataExtensions.GetTable<ServerCommit>(context);
         var commitId = Guid.NewGuid();
         var changeEntity = new ChangeEntity<ServerJsonChange>
         {
@@ -87,21 +86,23 @@ public async Task CanQueryOldCommits()
         //the old format stored json in json, this is emulating that.
         changeEntityJson["Change"] = changeEntityJson["Change"]?.ToJsonString();
         var jsonPayload = changeEntityJson.ToJsonString();
-        var inlineSql = $"'[{jsonPayload}]'::jsonb";
-        //insert a new server commit, manually specifying the value for ChangeEntities so it will match the old format.
-        await LinqToDB.LinqExtensions.InsertAsync(table, () => new ServerCommit(commitId)
-        {
-            Id = commitId,
-            ClientId = Guid.NewGuid(),
-            HybridDateTime = new HybridDateTime(DateTimeOffset.UtcNow, 0)
-            {
-                DateTime = DateTimeOffset.UtcNow,
-                Counter = 0
-            },
-            ProjectId = projectId,
-            Metadata = new CommitMetadata(),
-            ChangeEntities = LinqToDB.Sql.Expr<List<ChangeEntity<ServerJsonChange>>>(inlineSql)
-        });
+        //Insert a synthetic old-format commit via raw SQL so we can put pre-serialized
+        //JSON in ChangeEntities. Linq2Db v6 unconditionally wraps any column assignment
+        //(including Sql.Expr) in the EF JSON value converter inside an InsertAsync
+        //projection lambda, so we can't use the typed API for this test case.
+        var inlinePayload = $"[{jsonPayload}]";
+        await LinqToDB.Data.DataContextExtensions.ExecuteAsync(
+            context,
+            """
+            INSERT INTO "CrdtCommits"
+                ("Id", "ClientId", "HybridDateTime_DateTime", "HybridDateTime_Counter", "ProjectId", "Metadata", "ChangeEntities")
+            VALUES (@id, @clientId, @dt, 0, @projectId, '{}'::jsonb, @payload::jsonb)
+            """,
+            new LinqToDB.Data.DataParameter("id", commitId, LinqToDB.DataType.Guid),
+            new LinqToDB.Data.DataParameter("clientId", Guid.NewGuid(), LinqToDB.DataType.Guid),
+            new LinqToDB.Data.DataParameter("dt", DateTimeOffset.UtcNow, LinqToDB.DataType.DateTimeOffset),
+            new LinqToDB.Data.DataParameter("projectId", projectId, LinqToDB.DataType.Guid),
+            new LinqToDB.Data.DataParameter("payload", inlinePayload, LinqToDB.DataType.NVarChar));
         var commits = await _lexBoxDbContext.CrdtCommits(projectId).ToArrayAsync();
         var actualCommit = commits.Should().ContainSingle(c => c.Id == commitId).Subject;
         actualCommit.ChangeEntities.Should().BeEquivalentTo([changeEntity],