Sync morph type data

.github/workflows/fw-lite.yaml

@@ -21,7 +21,7 @@ on:
     branches:
       - develop
       - main
-      - shadcn-ui-main #just for now ensure PRs to this branch have checks run
+      - feat/sync-morph-types #just for now ensure PRs to this branch have checks run
 env:
   VIEWER_BUILD_OUTPUT_DIR: backend/FwLite/FwLiteShared/wwwroot/viewer
 jobs:

backend/FwLite/FwDataMiniLcmBridge.Tests/MiniLcmTests/SortingTests.cs

@@ -1,4 +1,7 @@
+using FwDataMiniLcmBridge.Api;
+using FwDataMiniLcmBridge.LcmUtils;
 using FwDataMiniLcmBridge.Tests.Fixtures;
+using MiniLcm.Models;
 
 namespace FwDataMiniLcmBridge.Tests.MiniLcmTests;
 
@@ -9,4 +12,42 @@ protected override Task<IMiniLcmApi> NewApi()
     {
         return Task.FromResult<IMiniLcmApi>(fixture.NewProjectApi("sorting-test", "en", "en"));
     }
+
+    [Theory]
+    [InlineData("aaaa", SortField.Headword)] // FTS
+    [InlineData("a", SortField.Headword)] // non-FTS
+    [InlineData("aaaa", SortField.SearchRelevance)] // FTS
+    [InlineData("a", SortField.SearchRelevance)] // non-FTS
+    public async Task SecondaryOrder_DefaultsToStem(string query, SortField sortField)
+    {
+        var unknownMorphTypeEntryId = Guid.NewGuid();
+        Entry[] expected = [
+            new() { Id = unknownMorphTypeEntryId, LexemeForm = { ["en"] = "aaaa" }, MorphType = MorphTypeKind.Unknown }, // SecondaryOrder defaults to Stem = 1
+            new() { Id = Guid.NewGuid(), LexemeForm = { ["en"] = "aaaa" }, MorphType = MorphTypeKind.BoundStem }, // SecondaryOrder = 2
+            new() { Id = Guid.NewGuid(), LexemeForm = { ["en"] = "aaaa" }, MorphType = MorphTypeKind.Suffix }, // SecondaryOrder = 6
+        ];
+
+        var ids = expected.Select(e => e.Id).ToHashSet();
+
+        foreach (var entry in Faker.Faker.Random.Shuffle(expected))
+            await Api.CreateEntry(entry);
+
+        var fwDataApi = (BaseApi as FwDataMiniLcmApi)!;
+        await fwDataApi.Cache.DoUsingNewOrCurrentUOW("Clear morph type",
+            "Revert morph type",
+            () =>
+            {
+                // the fwdata api doesn't allow creating entries with MorphType.Other or Unknown, so we force it
+                var unknownMorphTypeEntry = fwDataApi.EntriesRepository.GetObject(unknownMorphTypeEntryId);
+                unknownMorphTypeEntry.LexemeFormOA.MorphTypeRA = null;
+                return ValueTask.CompletedTask;
+            });
+
+        var results = (await Api.SearchEntries(query, new(new(sortField))).ToArrayAsync())
+            .Where(e => ids.Contains(e.Id))
+            .ToList();
+
+        results.Should().BeEquivalentTo(expected,
+            options => options.WithStrictOrdering());
+    }
 }

backend/FwLite/FwDataMiniLcmBridge/Api/FwDataMiniLcmApi.cs

@@ -541,7 +541,7 @@ await Cache.DoUsingNewOrCurrentUOW("Delete Complex Form Type",
             });
     }
 
-    public IAsyncEnumerable<MorphTypeData> GetAllMorphTypeData()
+    public IAsyncEnumerable<MorphType> GetMorphTypes()
     {
         return
             MorphTypeRepository
@@ -550,35 +550,44 @@ public IAsyncEnumerable<MorphTypeData> GetAllMorphTypeData()
             .Select(FromLcmMorphType);
     }
 
-    public Task<MorphTypeData?> GetMorphTypeData(Guid id)
+    public Task<MorphType?> GetMorphType(Guid id)
     {
         MorphTypeRepository.TryGetObject(id, out var lcmMorphType);
-        if (lcmMorphType is null) return Task.FromResult<MorphTypeData?>(null);
-        return Task.FromResult<MorphTypeData?>(FromLcmMorphType(lcmMorphType));
+        if (lcmMorphType is null) return Task.FromResult<MorphType?>(null);
+        return Task.FromResult<MorphType?>(FromLcmMorphType(lcmMorphType));
     }
 
-    internal MorphTypeData FromLcmMorphType(IMoMorphType morphType)
+    public Task<MorphType?> GetMorphType(MorphTypeKind kind)
     {
-        return new MorphTypeData
+        var guid = LcmHelpers.ToLcmMorphTypeId(kind);
+        if (guid is null) return Task.FromResult<MorphType?>(null);
+        MorphTypeRepository.TryGetObject(guid.Value, out var lcmMorphType);
+        if (lcmMorphType is null) return Task.FromResult<MorphType?>(null);
+        return Task.FromResult<MorphType?>(FromLcmMorphType(lcmMorphType));
+    }
+
+    internal MorphType FromLcmMorphType(IMoMorphType morphType)
+    {
+        return new MorphType
         {
             Id = morphType.Guid,
-            MorphType = LcmHelpers.FromLcmMorphType(morphType),
+            Kind = LcmHelpers.FromLcmMorphType(morphType),
             Name = FromLcmMultiString(morphType.Name),
             Abbreviation = FromLcmMultiString(morphType.Abbreviation),
             Description = FromLcmMultiString(morphType.Description),
-            LeadingToken = morphType.Prefix,
-            TrailingToken = morphType.Postfix,
+            Prefix = morphType.Prefix,
+            Postfix = morphType.Postfix,
             SecondaryOrder = morphType.SecondaryOrder,
         };
     }
 
-    public Task<MorphTypeData> CreateMorphTypeData(MorphTypeData morphTypeData)
+    public Task<MorphType> CreateMorphType(MorphType morphType)
     {
         // Creating new morph types not allowed in FwData projects, so silently ignore operation
-        return Task.FromResult(morphTypeData);
+        return Task.FromResult(morphType);
     }
 
-    public Task<MorphTypeData> UpdateMorphTypeData(Guid id, UpdateObjectInput<MorphTypeData> update)
+    public Task<MorphType> UpdateMorphType(Guid id, UpdateObjectInput<MorphType> update)
     {
         var lcmMorphType = MorphTypeRepository.GetObject(id);
         if (lcmMorphType is null) throw new NullReferenceException($"unable to find morph type with id {id}");
@@ -587,19 +596,19 @@ public Task<MorphTypeData> UpdateMorphTypeData(Guid id, UpdateObjectInput<MorphT
             Cache.ServiceLocator.ActionHandler,
             () =>
             {
-                var updateProxy = new UpdateMorphTypeDataProxy(lcmMorphType, this);
+                var updateProxy = new UpdateMorphTypeProxy(lcmMorphType, this);
                 update.Apply(updateProxy);
             });
         return Task.FromResult(FromLcmMorphType(lcmMorphType));
     }
 
-    public async Task<MorphTypeData> UpdateMorphTypeData(MorphTypeData before, MorphTypeData after, IMiniLcmApi? api = null)
+    public async Task<MorphType> UpdateMorphType(MorphType before, MorphType after, IMiniLcmApi? api = null)
     {
-        await MorphTypeDataSync.Sync(before, after, api ?? this);
-        return await GetMorphTypeData(after.Id) ?? throw new NullReferenceException("unable to find morph type with id " + after.Id);
+        await MorphTypeSync.Sync(before, after, api ?? this);
+        return await GetMorphType(after.Id) ?? throw new NullReferenceException("unable to find morph type with id " + after.Id);
     }
 
-    public Task DeleteMorphTypeData(Guid id)
+    public Task DeleteMorphType(Guid id)
     {
         // Deleting morph types not allowed in FwData projects, so silently ignore operation
         return Task.CompletedTask;
@@ -643,7 +652,7 @@ private Entry FromLexEntry(ILexEntry entry)
     {
         try
         {
-            return new Entry
+            var result = new Entry
             {
                 Id = entry.Guid,
                 Note = FromLcmMultiString(entry.Comment),
@@ -661,6 +670,7 @@ private Entry FromLexEntry(ILexEntry entry)
                 // ILexEntry.PublishIn is a virtual property that inverts DoNotPublishInRC against all publications
                 PublishIn = entry.PublishIn.Select(FromLcmPossibility).ToList(),
             };
+            return result;
         }
         catch (Exception e)
         {
@@ -716,24 +726,22 @@ private ComplexFormComponent ToEntryReference(ILexEntry component, ILexEntry com
         return new ComplexFormComponent
         {
             ComponentEntryId = component.Guid,
-            ComponentHeadword = component.LexEntryHeadwordOrUnknown(),
+            ComponentHeadword = component.LexEntryHeadwordOrUnknown(applyMorphTokens: false), // match CRDT for now
             ComplexFormEntryId = complexEntry.Guid,
-            ComplexFormHeadword = complexEntry.LexEntryHeadwordOrUnknown(),
+            ComplexFormHeadword = complexEntry.LexEntryHeadwordOrUnknown(applyMorphTokens: false), // match CRDT for now
             Order = Order(component, complexEntry)
         };
     }
 
-
-
     private ComplexFormComponent ToSenseReference(ILexSense componentSense, ILexEntry complexEntry)
     {
         return new ComplexFormComponent
         {
             ComponentEntryId = componentSense.Entry.Guid,
             ComponentSenseId = componentSense.Guid,
-            ComponentHeadword = componentSense.Entry.LexEntryHeadwordOrUnknown(),
+            ComponentHeadword = componentSense.Entry.LexEntryHeadwordOrUnknown(applyMorphTokens: false), // match CRDT for now
             ComplexFormEntryId = complexEntry.Guid,
-            ComplexFormHeadword = complexEntry.LexEntryHeadwordOrUnknown(),
+            ComplexFormHeadword = complexEntry.LexEntryHeadwordOrUnknown(applyMorphTokens: false), // match CRDT for now
             Order = Order(componentSense, complexEntry)
         };
     }
@@ -930,12 +938,13 @@ private IEnumerable<ILexEntry> GetFilteredAndSortedEntries(Func<ILexEntry, bool>
     private IEnumerable<ILexEntry> ApplySorting(SortOptions order, IEnumerable<ILexEntry> entries, string? query)
     {
         var sortWs = GetWritingSystemHandle(order.WritingSystem, WritingSystemType.Vernacular);
+        var stemSecondaryOrder = MorphTypeRepository.GetObject(MoMorphTypeTags.kguidMorphStem).SecondaryOrder;
         if (order.Field == SortField.SearchRelevance)
         {
-            return entries.ApplyRoughBestMatchOrder(order, sortWs, query);
+            return entries.ApplyRoughBestMatchOrder(order, sortWs, stemSecondaryOrder, query);
         }
 
-        return order.ApplyOrder(entries, e => e.LexEntryHeadword(sortWs));
+        return entries.ApplyHeadwordOrder(order, sortWs, stemSecondaryOrder);
     }
 
     public IAsyncEnumerable<Entry> SearchEntries(string query, QueryOptions? options = null)
@@ -947,7 +956,7 @@ public IAsyncEnumerable<Entry> SearchEntries(string query, QueryOptions? options
     private Func<ILexEntry, bool>? EntrySearchPredicate(string? query = null)
     {
         if (string.IsNullOrEmpty(query)) return null;
-        return entry => entry.CitationForm.SearchValue(query) ||
+        return entry => entry.SearchHeadWord(query) || // CitationForm.SearchValue would be redundant
                         entry.LexemeFormOA?.Form.SearchValue(query) is true ||
                         entry.AllSenses.Any(s => s.Gloss.SearchValue(query));
     }