FW Lite push entry changes to frontend

backend/FwLite/LcmCrdt/CurrentProjectService.cs

@@ -17,10 +17,9 @@ public async ValueTask<ProjectData> GetProjectData()
         var key = CacheKey(Project);
         if (!memoryCache.TryGetValue(key, out object? result))
         {
-            using var entry = memoryCache.CreateEntry(key);
-            entry.SlidingExpiration = TimeSpan.FromMinutes(10);
             result = await dbContext.ProjectData.AsNoTracking().FirstAsync();
-            entry.Value = result;
+            memoryCache.Set(key, result);
+            memoryCache.Set(CacheKey(((ProjectData)result).Id), result);
         }
         if (result is null) throw new InvalidOperationException("Project data not found");
 
@@ -32,6 +31,16 @@ private static string CacheKey(CrdtProject project)
         return project.Name + "|ProjectData";
     }
 
+    private static string CacheKey(Guid projectId)
+    {
+        return $"ProjectData|{projectId}";
+    }
+
+    public static ProjectData? LookupProjectById(IMemoryCache memoryCache, Guid projectId)
+    {
+        return memoryCache.Get<ProjectData>(CacheKey(projectId));
+    }
+
     public async ValueTask<ProjectData> PopulateProjectDataCache()
     {
         var projectData = await GetProjectData();

backend/FwLite/LcmCrdt/ProjectsService.cs

@@ -83,6 +83,7 @@ internal static async Task SeedSystemData(DataModel dataModel, Guid clientId)
 
     public AsyncServiceScope CreateProjectScope(CrdtProject crdtProject)
     {
+        //todo make this helper method call `CurrentProjectService.PopulateProjectDataCache`
         var serviceScope = provider.CreateAsyncScope();
         SetProjectScope(crdtProject);
         return serviceScope;

backend/FwLite/LocalWebApp/Auth/AuthHelpers.cs

@@ -149,6 +149,12 @@ public async Task Logout()
         return auth?.Account.Username;
     }
 
+    public async ValueTask<string?> GetCurrentToken()
+    {
+        var auth = await GetAuth();
+        return auth?.AccessToken;
+    }
+
     /// <summary>
     /// will return null if no auth token is available
     /// </summary>

backend/FwLite/LocalWebApp/BackgroundSyncService.cs

@@ -1,25 +1,50 @@
 using System.Threading.Channels;
 using SIL.Harmony;
 using LcmCrdt;
-using LocalWebApp.Auth;
-using Microsoft.Extensions.Options;
-using MiniLcm;
+using Microsoft.Extensions.Caching.Memory;
 
 namespace LocalWebApp;
 
 public class BackgroundSyncService(
-    IServiceProvider serviceProvider,
     ProjectsService projectsService,
     IHostApplicationLifetime applicationLifetime,
-    IOptions<AuthConfig>options,
-    ProjectContext projectContext) : BackgroundService
+    ProjectContext projectContext,
+    ILogger<BackgroundSyncService> logger,
+    IMemoryCache memoryCache) : BackgroundService
 {
     private readonly Channel<CrdtProject> _syncResultsChannel = Channel.CreateUnbounded<CrdtProject>();
 
+    public void TriggerSync(Guid projectId, Guid? ignoredClientId = null)
+    {
+        var projectData = CurrentProjectService.LookupProjectById(memoryCache, projectId);
+        if (projectData is null)
+        {
+            logger.LogWarning("Received project update for unknown project {ProjectId}", projectId);
+            return;
+        }
+        if (ignoredClientId == projectData.ClientId)
+        {
+            logger.LogInformation("Received project update for {ProjectId} triggered by my own change, ignoring", projectId);
+            return;
+        }
+
+        var crdtProject = projectsService.GetProject(projectData.Name);
+        if (crdtProject is null)
+        {
+            logger.LogWarning("Received project update for unknown project {ProjectName}", projectData.Name);
+            return;
+        }
+
+        TriggerSync(crdtProject);
+    }
     public void TriggerSync()
     {
-        _syncResultsChannel.Writer.TryWrite(projectContext.Project ??
-                                            throw new InvalidOperationException("No project selected"));
+        TriggerSync(projectContext.Project ?? throw new InvalidOperationException("No project selected"));
+    }
+
+    public void TriggerSync(CrdtProject crdtProject)
+    {
+        _syncResultsChannel.Writer.TryWrite(crdtProject);
     }
 
     private Task StartedAsync()
@@ -50,6 +75,7 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
     private async Task<SyncResults> SyncProject(CrdtProject crdtProject)
     {
         await using var serviceScope = projectsService.CreateProjectScope(crdtProject);
+        await serviceScope.ServiceProvider.GetRequiredService<CurrentProjectService>().PopulateProjectDataCache();
         var syncService = serviceScope.ServiceProvider.GetRequiredService<SyncService>();
         return await syncService.ExecuteSync();
     }

backend/FwLite/LocalWebApp/CrdtHttpSyncService.cs

@@ -53,15 +53,15 @@
         var client = await authHelpersFactory.GetHelper(project).CreateClient();
         if (client is null)
         {
-            logger.LogWarning("Unable to create http client to sync project, user is not authenticated to {OriginDomain}", project.OriginDomain);
+            logger.LogWarning("Unable to create http client to sync project {ProjectName}, user is not authenticated to {OriginDomain}", project.Name, project.OriginDomain);
             return NullSyncable.Instance;
         }
 
-        return new CrdtProjectSync(RestService.For<ISyncHttp>(client, refitSettings), project.Id, project.OriginDomain, this);
+        return new CrdtProjectSync(RestService.For<ISyncHttp>(client, refitSettings), project.Id, project.ClientId  , project.OriginDomain, this);
     }
 }
 
-public class CrdtProjectSync(ISyncHttp restSyncClient, Guid projectId, string originDomain, CrdtHttpSyncService httpSyncService) : ISyncable
+public class CrdtProjectSync(ISyncHttp restSyncClient, Guid projectId, Guid clientId, string originDomain, CrdtHttpSyncService httpSyncService) : ISyncable
 {
     public ValueTask<bool> ShouldSync()
     {
@@ -70,7 +70,7 @@
 
     async Task ISyncable.AddRangeFromSync(IEnumerable<Commit> commits)
     {
-        await restSyncClient.AddRange(projectId, commits);
+        await restSyncClient.AddRange(projectId, commits, clientId);
     }
 
     async Task<ChangesResult<Commit>> ISyncable.GetChanges(SyncState otherHeads)
@@ -104,7 +104,7 @@
     Task<HttpResponseMessage> HealthCheck();
 
     [Post("/api/crdt/{id}/add")]
-    internal Task AddRange(Guid id, IEnumerable<Commit> commits);
+    internal Task AddRange(Guid id, IEnumerable<Commit> commits, Guid? clientId);
 
     [Get("/api/crdt/{id}/get")]
     internal Task<SyncState> GetSyncState(Guid id);

backend/FwLite/LocalWebApp/Hubs/CrdtMiniLcmApiHub.cs

@@ -1,4 +1,6 @@
-using Microsoft.AspNetCore.SignalR;
+using LcmCrdt;
+using LocalWebApp.Services;
+using Microsoft.AspNetCore.SignalR.Client;
 using MiniLcm;
 using SystemTextJsonPatch;
 
@@ -7,12 +9,21 @@ namespace LocalWebApp.Hubs;
 public class CrdtMiniLcmApiHub(
     ILexboxApi lexboxApi,
     BackgroundSyncService backgroundSyncService,
-    SyncService syncService) : MiniLcmApiHubBase(lexboxApi)
+    SyncService syncService,
+    ChangeEventBus changeEventBus,
+    CurrentProjectService projectContext,
+    LexboxProjectService lexboxProjectService) : MiniLcmApiHubBase(lexboxApi)
 {
     public const string ProjectRouteKey = "project";
+    public static string ProjectGroup(string projectName) => "crdt-" + projectName;
+
     public override async Task OnConnectedAsync()
     {
+        await Groups.AddToGroupAsync(Context.ConnectionId, ProjectGroup(projectContext.Project.Name));
         await syncService.ExecuteSync();
+        changeEventBus.SetupGlobalSignalRSubscription();
+
+        await lexboxProjectService.ListenForProjectChanges(projectContext.ProjectData, Context.ConnectionAborted);
     }
 
     public override async Task<WritingSystem> CreateWritingSystem(WritingSystemType type, WritingSystem writingSystem)
@@ -22,27 +33,15 @@ public override async Task<WritingSystem> CreateWritingSystem(WritingSystemType
         return newWritingSystem;
     }
 
-    public override async Task<WritingSystem> UpdateWritingSystem(WritingSystemId id, WritingSystemType type, JsonPatchDocument<WritingSystem> update)
+    public override async Task<WritingSystem> UpdateWritingSystem(WritingSystemId id,
+        WritingSystemType type,
+        JsonPatchDocument<WritingSystem> update)
     {
         var writingSystem = await base.UpdateWritingSystem(id, type, update);
         backgroundSyncService.TriggerSync();
         return writingSystem;
     }
 
-    public override async Task<Entry> CreateEntry(Entry entry)
-    {
-        var newEntry = await base.CreateEntry(entry);
-        await NotifyEntryUpdated(newEntry);
-        return newEntry;
-    }
-
-    public override async Task<Entry> UpdateEntry(Guid id, JsonPatchDocument<Entry> update)
-    {
-        var entry = await base.UpdateEntry(id, update);
-        await NotifyEntryUpdated(entry);
-        return entry;
-    }
-
     public override async Task<Sense> CreateSense(Guid entryId, Sense sense)
     {
         var createdSense = await base.CreateSense(entryId, sense);

backend/FwLite/LocalWebApp/LocalAppKernel.cs

@@ -22,6 +22,7 @@ public static IServiceCollection AddLocalAppServices(this IServiceCollection ser
         services.AddSingleton<UrlContext>();
         services.AddScoped<SyncService>();
         services.AddScoped<LexboxProjectService>();
+        services.AddSingleton<ChangeEventBus>();
         services.AddSingleton<ImportFwdataService>();
         services.AddSingleton<BackgroundSyncService>();
         services.AddSingleton<IHostedService>(s => s.GetRequiredService<BackgroundSyncService>());

backend/FwLite/LocalWebApp/LocalWebApp.csproj

@@ -19,11 +19,13 @@
         <PackageReference Include="Humanizer.Core" Version="2.14.1" />
         <PackageReference Include="icu.net" Version="2.10.1-beta.5" GeneratePathProperty="true" />
         <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="8.0.4"/>
+        <PackageReference Include="Microsoft.AspNetCore.SignalR.Client" Version="8.0.8" />
         <PackageReference Include="Microsoft.Extensions.FileProviders.Embedded" Version="8.0.4" />
-        <PackageReference Include="Microsoft.Identity.Client.Extensions.Msal" Version="4.61.0" />
+        <PackageReference Include="Microsoft.Identity.Client.Extensions.Msal" Version="4.63.0" />
         <PackageReference Include="Refit" Version="7.0.0" />
         <PackageReference Include="Refit.HttpClientFactory" Version="7.0.0" />
         <PackageReference Include="Swashbuckle.AspNetCore" Version="6.4.0"/>
+        <PackageReference Include="System.Reactive" Version="6.0.1" />
     </ItemGroup>
 
     <ItemGroup>

backend/FwLite/LocalWebApp/Routes/TestRoutes.cs

@@ -1,7 +1,5 @@
-using SIL.Harmony.Core;
-using SIL.Harmony.Db;
-using LocalWebApp.Hubs;
-using Microsoft.EntityFrameworkCore;
+using LocalWebApp.Hubs;
+using LocalWebApp.Services;
 using Microsoft.OpenApi.Models;
 using MiniLcm;
 using Entry = LcmCrdt.Objects.Entry;
@@ -27,6 +25,12 @@ public static IEndpointConventionBuilder MapTest(this WebApplication app)
             {
                 return api.GetEntries();
             });
+        group.MapPost("/set-entry-note", async (ILexboxApi api, ChangeEventBus eventBus, Guid entryId, string ws, string note) =>
+        {
+            var entry = await api.UpdateEntry(entryId, api.CreateUpdateBuilder<MiniLcm.Entry>().Set(e => e.Note[ws], note).Build());
+            if (entry is Entry crdtEntry)
+                eventBus.NotifyEntryUpdated(crdtEntry);
+        });
         return group;
     }
 }

backend/FwLite/LocalWebApp/Services/ChangeEventBus.cs

@@ -0,0 +1,50 @@
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using LcmCrdt;
+using LcmCrdt.Objects;
+using LocalWebApp.Hubs;
+using Microsoft.AspNetCore.SignalR;
+
+namespace LocalWebApp.Services;
+
+public class ChangeEventBus(ProjectContext projectContext, IHubContext<CrdtMiniLcmApiHub, ILexboxHubClient> hubContext, ILogger<ChangeEventBus> logger)
+    : IDisposable
+{
+    private IDisposable? _subscription;
+
+    public void SetupGlobalSignalRSubscription()
+    {
+        if (_subscription is not null) return;
+        _subscription = _entryUpdated.Subscribe(notification =>
+        {
+            logger.LogInformation("Sending notification for {EntryId} to {ProjectName}", notification.Entry.Id, notification.ProjectName);
+            _ = hubContext.Clients.Group(CrdtMiniLcmApiHub.ProjectGroup(notification.ProjectName)).OnEntryUpdated(notification.Entry);
+        });
+    }
+
+    private record struct ChangeNotification(Entry Entry, string ProjectName);
+
+    private readonly Subject<ChangeNotification> _entryUpdated = new();
+
+    public IObservable<Entry> OnEntryUpdated
+    {
+        get
+        {
+            var projectName = projectContext.Project?.Name ?? throw new InvalidOperationException("Not in a project");
+            return _entryUpdated
+                .Where(n => n.ProjectName == projectName)
+                .Select(n => n.Entry);
+        }
+    }
+
+    public void NotifyEntryUpdated(Entry entry)
+    {
+        _entryUpdated.OnNext(new ChangeNotification(entry,
+            projectContext.Project?.Name ?? throw new InvalidOperationException("Not in a project")));
+    }
+
+    public void Dispose()
+    {
+        _subscription?.Dispose();
+    }
+}