(CommunityToolkit#298) Conflict resolver.

Author: adrianhall

src/CommunityToolkit.Datasync.Client/Offline/ConflictResolvers.cs

@@ -0,0 +1,47 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace CommunityToolkit.Datasync.Client.Offline;
+
+/// <summary>
+/// An abstract class that provides a mechanism for resolving conflicts between client and server objects of a specified
+/// type asynchronously.  The object edition of the conflict resolver just calls the typed version.
+/// </summary>
+/// <typeparam name="TEntity">The type of entity being resolved.</typeparam>
+public abstract class AbstractConflictResolver<TEntity> : IConflictResolver<TEntity>
+{
+    /// <inheritdoc />
+    public abstract Task<TEntity?> ResolveConflictAsync(TEntity? clientObject, TEntity? serverObject, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// The object version of the resolver calls the typed version.
+    /// </summary>
+    /// <param name="clientObject"></param>
+    /// <param name="serverObject"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    public virtual async Task<object?> ResolveConflictAsync(object? clientObject, object? serverObject, CancellationToken cancellationToken = default)
+        => await ResolveConflictAsync((TEntity?)clientObject, (TEntity?)serverObject, cancellationToken);
+}
+
+/// <summary>
+/// A conflict resolver where the client object always wins.
+/// </summary>
+public class ClientWinsConflictResolver : IConflictResolver
+{
+    /// <inheritdoc />
+    public Task<object?> ResolveConflictAsync(object? clientObject, object? serverObject, CancellationToken cancellationToken = default)
+        => Task.FromResult(clientObject);
+}
+
+/// <summary>
+/// A conflict resolver where the server object always wins.
+/// </summary>
+public class ServerWinsConflictResolver : IConflictResolver
+{
+    /// <inheritdoc />
+    public Task<object?> ResolveConflictAsync(object? clientObject, object? serverObject, CancellationToken cancellationToken = default)
+        => Task.FromResult(serverObject);
+}
+

src/CommunityToolkit.Datasync.Client/Offline/DatasyncOfflineOptionsBuilder.cs

@@ -164,6 +164,11 @@ public class EntityOfflineOptions(Type entityType)
         /// </summary>
         public Uri Endpoint { get; set; } = new Uri($"/tables/{entityType.Name.ToLowerInvariant()}", UriKind.Relative);
 
+        /// <summary>
+        /// The conflict resolver for this entity.
+        /// </summary>
+        public IConflictResolver? ConflictResolver { get; set; }
+
         /// <summary>
         /// The query description for the entity type - may be null (to mean "pull everything").
         /// </summary>
@@ -186,6 +191,11 @@ public class EntityOfflineOptions<TEntity>() where TEntity : class
         /// </summary>
         public string ClientName { get; set; } = string.Empty;
 
+        /// <summary>
+        /// The conflict resolver for this entity.
+        /// </summary>
+        public IConflictResolver? ConflictResolver { get; set; }
+
         /// <summary>
         /// The endpoint for the entity type.
         /// </summary>

src/CommunityToolkit.Datasync.Client/Offline/IConflictResolver.cs

@@ -0,0 +1,40 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace CommunityToolkit.Datasync.Client.Offline;
+
+/// <summary>
+/// Definition of a conflict resolver.  This is used in push situations where
+/// the server returns a 409 or 412 status code indicating that the client is
+/// out of step with the server.
+/// </summary>
+public interface IConflictResolver
+{
+    /// <summary>
+    /// Resolves the conflict between two objects - client side and server side.
+    /// </summary>
+    /// <param name="clientObject">The client object.</param>
+    /// <param name="serverObject">The server object.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe.</param>
+    /// <returns>The conflict resolution.</returns>
+    Task<object?> ResolveConflictAsync(object? clientObject, object? serverObject, CancellationToken cancellationToken = default);
+}
+
+/// <summary>
+/// Definition of a conflict resolver.  This is used in push situations where
+/// the server returns a 409 or 412 status code indicating that the client is
+/// out of step with the server.
+/// </summary>
+/// <typeparam name="TEntity">The type of the entity.</typeparam>
+public interface IConflictResolver<TEntity> : IConflictResolver
+{
+    /// <summary>
+    /// Resolves the conflict between two objects - client side and server side.
+    /// </summary>
+    /// <param name="clientObject">The client object.</param>
+    /// <param name="serverObject">The server object.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe.</param>
+    /// <returns>The conflict resolution.</returns>
+    Task<TEntity?> ResolveConflictAsync(TEntity? clientObject, TEntity? serverObject, CancellationToken cancellationToken = default);
+}

src/CommunityToolkit.Datasync.Client/Offline/Models/EntityDatasyncOptions.cs

@@ -11,6 +11,11 @@ namespace CommunityToolkit.Datasync.Client.Offline.Models;
 /// </summary>
 internal class EntityDatasyncOptions
 {
+    /// <summary>
+    /// The conflict resolver for the entity.
+    /// </summary>
+    internal IConflictResolver? ConflictResolver { get; init; }
+
     /// <summary>
     /// The endpoint for the entity type.
     /// </summary>

src/CommunityToolkit.Datasync.Client/Offline/Models/OfflineOptions.cs

@@ -43,6 +43,7 @@ public EntityDatasyncOptions GetOptions(Type entityType)
         {
             return new()
             {
+                ConflictResolver = options.ConflictResolver,
                 Endpoint = options.Endpoint,
                 HttpClient = HttpClientFactory.CreateClient(options.ClientName),
                 QueryDescription = options.QueryDescription ?? new QueryDescription()
@@ -52,6 +53,7 @@ public EntityDatasyncOptions GetOptions(Type entityType)
         {
             return new()
             {
+                ConflictResolver = null,
                 Endpoint = new Uri($"tables/{entityType.Name.ToLowerInvariant()}", UriKind.Relative),
                 HttpClient = HttpClientFactory.CreateClient(),
                 QueryDescription = new QueryDescription()
@@ -69,6 +71,11 @@ internal class EntityOptions
         /// </summary>
         public required string ClientName { get; set; }
 
+        /// <summary>
+        /// The conflict resolver for the entity options.
+        /// </summary>
+        internal IConflictResolver? ConflictResolver { get; set; }
+
         /// <summary>
         /// The endpoint for the entity type.
         /// </summary>

src/CommunityToolkit.Datasync.Client/Offline/OperationsQueue/OperationsQueueManager.cs

@@ -299,6 +299,29 @@ internal async Task<PushResult> PushAsync(IEnumerable<Type> entityTypes, PushOpt
         ExecutableOperation op = await ExecutableOperation.CreateAsync(operation, cancellationToken).ConfigureAwait(false);
         ServiceResponse response = await op.ExecuteAsync(options, cancellationToken).ConfigureAwait(false);
 
+        if (response.IsConflictStatusCode && options.ConflictResolver is not null)
+        {
+            object? serverEntity = JsonSerializer.Deserialize(response.ContentStream, entityType, DatasyncSerializer.JsonSerializerOptions);
+            object? clientEntity = JsonSerializer.Deserialize(operation.Item, entityType, DatasyncSerializer.JsonSerializerOptions);
+            object? resolvedEntity = await options.ConflictResolver.ResolveConflictAsync(clientEntity, serverEntity, cancellationToken).ConfigureAwait(false);
+            if (resolvedEntity is not null)
+            {
+                lock (this.pushlock)
+                {
+                    operation.Item = JsonSerializer.Serialize(resolvedEntity, entityType, DatasyncSerializer.JsonSerializerOptions);
+                    operation.State = OperationState.Pending;
+                    operation.LastAttempt = DateTimeOffset.UtcNow;
+                    operation.HttpStatusCode = response.StatusCode;
+                    operation.EntityVersion = string.Empty; // Force the push
+                    operation.Version++;
+                    _ = this._context.Update(operation);
+                }
+
+                ExecutableOperation resolveOperation = await ExecutableOperation.CreateAsync(operation, cancellationToken).ConfigureAwait(false);
+                response = await resolveOperation.ExecuteAsync(options, cancellationToken).ConfigureAwait(false);
+            }
+        }
+
         if (!response.IsSuccessful)
         {
             lock (this.pushlock)