Add synced app-defined metadata for remote resources

src/SIL.Harmony.Core/IRemoteResourceService.cs

@@ -5,7 +5,7 @@
 /// the remote Id is opaque to the CRDT lib and could be a URL or some other identifier provided by the backend
 /// the local path returned for the application code to use as required, it could be a URL if needed also.
 /// </summary>
-public interface IRemoteResourceService
+public interface IRemoteResourceService<TMetadata> where TMetadata : class
 {
     /// <summary>
     /// instructs application code to download a resource from the remote server
@@ -22,8 +22,8 @@ public interface IRemoteResourceService
     /// <param name="resourceId">id of the resource in the CRDT</param>
     /// <param name="localPath">full path to the resource on the local machine</param>
     /// <returns>an upload result with the remote id, the id will be stored and transmitted to other clients so they can also download the resource</returns>
-    Task<UploadResult> UploadResource(Guid resourceId, string localPath);
+    Task<UploadResult<TMetadata>> UploadResource(Guid resourceId, string localPath, TMetadata? metadata = null);
 }
 
 public record DownloadResult(string LocalPath);
-public record UploadResult(string RemoteId);
+public record UploadResult<TMetadata>(string RemoteId, TMetadata? Metadata = null) where TMetadata : class;

src/SIL.Harmony.Sample/CrdtSampleKernel.cs

@@ -36,7 +36,6 @@ public static IServiceCollection AddCrdtDataSample(this IServiceCollection servi
         services.AddCrdtData<SampleDbContext>(config =>
         {
             config.EnableProjectedTables = true;
-            config.AddRemoteResourceEntity();
             config.ChangeTypeListBuilder
                 .Add<NewWordChange>()
                 .Add<NewDefinitionChange>()
@@ -84,6 +83,7 @@ public static IServiceCollection AddCrdtDataSample(this IServiceCollection servi
                     builder.HasIndex(wt => new { wt.WordId, wt.TagId }).IsUnique();
                 });
         });
+        services.AddCrdtRemoteResources<MediaMetadata>();
         return services;
     }
 }

src/SIL.Harmony.Sample/MediaMetadata.cs

@@ -0,0 +1,3 @@
+namespace SIL.Harmony.Sample;
+
+public record MediaMetadata(string FileName, string MimeType, long SizeBytes);

src/SIL.Harmony.Tests/DbContextTests.VerifyModel.verified.txt

@@ -93,16 +93,19 @@
       Relational:TableName: LocalResource
       Relational:ViewName: 
       Relational:ViewSchema: 
-  EntityType: RemoteResource
+  EntityType: RemoteResource<MediaMetadata>
     Properties: 
       Id (Guid) Required PK AfterSave:Throw ValueGenerated.OnAdd
       DeletedAt (DateTimeOffset?)
+      Metadata (MediaMetadata)
+        Annotations: 
+          Relational:ColumnType: jsonb
       RemoteId (string)
       SnapshotId (no field, Guid?) Shadow FK Index
     Keys: 
       Id PK
     Foreign keys: 
-      RemoteResource {'SnapshotId'} -> ObjectSnapshot {'Id'} Unique SetNull
+      RemoteResource<MediaMetadata> {'SnapshotId'} -> ObjectSnapshot {'Id'} Unique SetNull
     Indexes: 
       SnapshotId Unique
     Annotations: 

src/SIL.Harmony.Tests/ResourceTests/RemoteResourcesMetadataTests.cs

@@ -0,0 +1,162 @@
+using System.Runtime.CompilerServices;
+using Microsoft.Extensions.DependencyInjection;
+using SIL.Harmony.Resource;
+using SIL.Harmony.Sample;
+
+namespace SIL.Harmony.Tests.ResourceTests;
+
+public class RemoteResourcesMetadataTests : DataModelTestBase
+{
+    private RemoteServiceMock _remoteServiceMock = new();
+    private ResourceService<MediaMetadata> _resourceService =>
+        _services.GetRequiredService<ResourceService<MediaMetadata>>();
+
+    private string CreateFile(string contents, [CallerMemberName] string fileName = "")
+    {
+        var filePath = Path.GetFullPath(fileName + ".txt");
+        File.WriteAllText(filePath, contents);
+        return filePath;
+    }
+
+    private static MediaMetadata SampleMetadata(string fileName = "photo.jpg") =>
+        new(fileName, "image/jpeg", 102400);
+
+    [Fact]
+    public async Task CreateWithUpload_UsesPassedMetadataWhenUploadReturnsNone()
+    {
+        var metadata = SampleMetadata();
+        var localFile = CreateFile("image data");
+        var resource = await _resourceService.AddLocalResource(localFile, _localClientId, metadata,
+            resourceService: _remoteServiceMock);
+        resource.Metadata.Should().BeEquivalentTo(metadata);
+        var stored = await DataModel.GetLatest<RemoteResource<MediaMetadata>>(resource.Id);
+        stored!.Metadata.Should().BeEquivalentTo(metadata);
+        (await _resourceService.GetResource(resource.Id))!.Metadata.Should().BeEquivalentTo(metadata);
+    }
+
+    [Fact]
+    public async Task CreateWithUpload_UploadMetadataOverridesPassedMetadata()
+    {
+        var passedMetadata = SampleMetadata("passed.jpg");
+        var uploadMetadata = new MediaMetadata("from-upload.jpg", "image/png", 204800);
+        var localFile = CreateFile("image data");
+        _remoteServiceMock.SetUploadMetadata(localFile, uploadMetadata);
+        var resource = await _resourceService.AddLocalResource(localFile, _localClientId, passedMetadata,
+            resourceService: _remoteServiceMock);
+        resource.Metadata.Should().BeEquivalentTo(uploadMetadata);
+        resource.Metadata.Should().NotBeEquivalentTo(passedMetadata);
+        var stored = await DataModel.GetLatest<RemoteResource<MediaMetadata>>(resource.Id);
+        stored!.Metadata.Should().BeEquivalentTo(uploadMetadata);
+        (await _resourceService.GetResource(resource.Id))!.Metadata.Should().BeEquivalentTo(uploadMetadata);
+    }
+
+    [Fact]
+    public async Task CreatePendingUpload_IncludesMetadata()
+    {
+        var metadata = SampleMetadata("pending.mp4");
+        var localFile = CreateFile("video data");
+        var resource = await _resourceService.AddLocalResource(localFile, _localClientId, metadata,
+            resourceService: null);
+        resource.Metadata.Should().BeEquivalentTo(metadata);
+        var stored = await DataModel.GetLatest<RemoteResource<MediaMetadata>>(resource.Id);
+        stored!.Metadata.Should().BeEquivalentTo(metadata);
+    }
+
+    [Fact]
+    public async Task UploadPendingResource_IncludesMetadata()
+    {
+        var metadata = SampleMetadata("pending.mp4");
+        var localFile = CreateFile("video data");
+        var resource = await _resourceService.AddLocalResource(localFile, _localClientId, metadata,
+            resourceService: null);
+        _remoteServiceMock.SetUploadMetadata(localFile, SampleMetadata("FromUpload.mp4"));
+        await _resourceService.UploadPendingResource(resource.Id, _localClientId, _remoteServiceMock);
+        var stored = await DataModel.GetLatest<RemoteResource<MediaMetadata>>(resource.Id);
+        stored!.Metadata.Should().BeEquivalentTo(SampleMetadata("FromUpload.mp4"));
+    }
+
+    [Fact]
+    public async Task UploadPendingResources_IncludesMetadata()
+    {
+        var metadata = SampleMetadata("pending.mp4");
+        var localFile = CreateFile("video data");
+        var resource = await _resourceService.AddLocalResource(localFile, _localClientId, metadata,
+            resourceService: null);
+        _remoteServiceMock.SetUploadMetadata(localFile, SampleMetadata("FromUpload.mp4"));
+        await _resourceService.UploadPendingResources(_localClientId, _remoteServiceMock);
+        var stored = await DataModel.GetLatest<RemoteResource<MediaMetadata>>(resource.Id);
+        stored!.Metadata.Should().BeEquivalentTo(SampleMetadata("FromUpload.mp4"));
+    }
+
+    [Fact]
+    public async Task UploadPendingResources_PreservesMetadataWhenUploadReturnsNone()
+    {
+        var metadata = SampleMetadata("pending.mp4");
+        var localFile = CreateFile("video data");
+        var resource = await _resourceService.AddLocalResource(localFile, _localClientId, metadata,
+            resourceService: null);
+
+        await _resourceService.UploadPendingResources(_localClientId, new NullMetadataRemoteService());
+
+        var stored = await DataModel.GetLatest<RemoteResource<MediaMetadata>>(resource.Id);
+        stored!.RemoteId.Should().NotBeNull();
+        stored.Metadata.Should().BeEquivalentTo(metadata);
+    }
+
+    [Fact]
+    public async Task AllResources_IncludesMetadata()
+    {
+        var metadata = SampleMetadata();
+        var localFile = CreateFile("list test");
+        await _resourceService.AddLocalResource(localFile, _localClientId, metadata, resourceService: _remoteServiceMock);
+        var all = await _resourceService.AllResources();
+        all.Should().ContainSingle().Which.Metadata.Should().BeEquivalentTo(metadata);
+    }
+
+    [Fact]
+    public async Task SetResourceMetadata_UpdatesAndSyncs()
+    {
+        var metadata = SampleMetadata();
+        var localFile = CreateFile("sync test");
+        var resource = await _resourceService.AddLocalResource(localFile, _localClientId, metadata,
+            resourceService: _remoteServiceMock);
+        var remoteClient = ForkDatabase();
+        var updated = metadata with { FileName = "renamed.jpg" };
+        await _resourceService.SetResourceMetadata(resource.Id, _localClientId, updated);
+        await DataModel.SyncWith(remoteClient.DataModel);
+        (await _resourceService.GetResource(resource.Id))!.Metadata.Should().BeEquivalentTo(updated);
+        (await remoteClient.DataModel.GetLatest<RemoteResource<MediaMetadata>>(resource.Id))!.Metadata
+            .Should().BeEquivalentTo(updated);
+    }
+
+    [Fact]
+    public async Task CreateWithoutMetadata_DeserializesWithNullMetadata()
+    {
+        var resourceId = Guid.NewGuid();
+        var remoteId = _remoteServiceMock.CreateRemoteResource("legacy");
+        await DataModel.AddChange(_localClientId,
+            new CreateRemoteResourceChange<MediaMetadata>(resourceId, remoteId));
+        var stored = await DataModel.GetLatest<RemoteResource<MediaMetadata>>(resourceId);
+        stored!.Metadata.Should().BeNull();
+        stored.RemoteId.Should().Be(remoteId);
+    }
+
+    private sealed class NullMetadataRemoteService : IRemoteResourceService<MediaMetadata>
+    {
+        private static readonly string RemotePath = Directory.CreateTempSubdirectory("NullMetadataRemoteService").FullName;
+
+        public Task<DownloadResult> DownloadResource(string remoteId, string localResourceCachePath)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task<UploadResult<MediaMetadata>> UploadResource(Guid resourceId, string localPath,
+            MediaMetadata? metadata = null)
+        {
+            var remoteId = Path.Combine(RemotePath, $"{Guid.NewGuid():N}-{Path.GetFileName(localPath)}");
+            File.Copy(localPath, remoteId);
+            return Task.FromResult(new UploadResult<MediaMetadata>(remoteId));
+        }
+    }
+}
+