Re-organization of internal OfflineDbContext APIs (#69)

Author: adrianhall

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

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using CommunityToolkit.Datasync.Client.Http;
+using CommunityToolkit.Datasync.Client.Offline.Internal;
 
 namespace CommunityToolkit.Datasync.Client.Offline;
 
@@ -105,25 +106,26 @@ public DatasyncOfflineOptionsBuilder Entity(Type entityType, Action<EntityOfflin
     }
 
     /// <summary>
-    /// Retrieves the offline options for the entity type.
+    /// Converts the builder into a read-only set of options.
     /// </summary>
-    /// <param name="entityType">The entity type.</param>
-    /// <returns>The offline options for the entity type.</returns>
-    internal DatasyncOfflineOptions GetOfflineOptions(Type entityType)
+    /// <returns>The offline options built from this builder.</returns>
+    internal OfflineOptions Build()
     {
-        ArgumentNullException.ThrowIfNull(entityType, nameof(entityType));
         if (this._httpClientFactory == null)
         {
             throw new DatasyncException($"Datasync service connection is not set.");
         }
 
-        if (!this._entities.TryGetValue(entityType.FullName!, out EntityOfflineOptions? options))
+        OfflineOptions result = new()
         {
-            throw new DatasyncException($"Entity is not synchronizable.");
+            HttpClientFactory = this._httpClientFactory
+        };
+        foreach (EntityOfflineOptions entity in this._entities.Values)
+        {
+            result.AddEntity(entity.EntityType, entity.ClientName, entity.Endpoint);
         }
 
-        HttpClient client = this._httpClientFactory.CreateClient(options.ClientName);
-        return new DatasyncOfflineOptions(client, options.Endpoint);
+        return result;
     }
 
     /// <summary>

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

@@ -42,4 +42,12 @@ public static Task<PushOperationResult> PushAsync<TEntity>(this DbSet<TEntity> s
             throw new DatasyncException("DbContext for this dataset is not an OfflineDbContext.");
         }
     }
+
+    /// <summary>
+    /// Converts the string to an empty string if null.
+    /// </summary>
+    /// <param name="value">The value to convert.</param>
+    /// <returns>The converted value.</returns>
+    public static string AsNullableEmptyString(this string? value)
+        => value ?? string.Empty;
 }

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

@@ -0,0 +1,30 @@
+// 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.Internal;
+
+/// <summary>
+/// The executable operation for an "ADD" operation.
+/// </summary>
+/// <param name="operation">The operation to execute.</param>
+internal class AddOperation(DatasyncOperation operation) : ExecutableOperation
+{
+    /// <summary>
+    /// Performs the push operation, returning the result of the push operation.
+    /// </summary>
+    /// <param name="client">The <see cref="HttpClient"/> to use for communicating with the datasync service.</param>
+    /// <param name="endpoint">The fully-qualified URI to the table endpoint.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe.</param>
+    /// <returns>The result of the push operation (async).</returns>
+    internal override async Task<ServiceResponse> ExecuteAsync(HttpClient client, Uri endpoint, CancellationToken cancellationToken = default)
+    {
+        endpoint = MakeAbsoluteUri(client.BaseAddress, endpoint);
+        using HttpRequestMessage request = new(HttpMethod.Post, endpoint)
+        {
+            Content = new StringContent(operation.Item, JsonMediaType)
+        };
+        using HttpResponseMessage response = await client.SendAsync(request, cancellationToken).ConfigureAwait(false);
+        return new ServiceResponse(response);
+    }
+}

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

@@ -0,0 +1,34 @@
+// 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.
+
+using System.Net.Http.Headers;
+
+namespace CommunityToolkit.Datasync.Client.Offline.Internal;
+
+/// <summary>
+/// The executable operation for a "DELETE" operation.
+/// </summary>
+/// <param name="operation">The operation to execute.</param>
+internal class DeleteOperation(DatasyncOperation operation) : ExecutableOperation
+{
+    /// <summary>
+    /// Performs the push operation, returning the result of the push operation.
+    /// </summary>
+    /// <param name="client">The <see cref="HttpClient"/> to use for communicating with the datasync service.</param>
+    /// <param name="endpoint">The fully-qualified URI to the table endpoint.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe.</param>
+    /// <returns>The result of the push operation (async).</returns>
+    internal override async Task<ServiceResponse> ExecuteAsync(HttpClient client, Uri endpoint, CancellationToken cancellationToken = default)
+    {
+        endpoint = MakeAbsoluteUri(client.BaseAddress, endpoint);
+        using HttpRequestMessage request = new(HttpMethod.Delete, new Uri(endpoint, operation.ItemId));
+        if (!string.IsNullOrEmpty(operation.EntityVersion))
+        {
+            request.Headers.IfMatch.Add(new EntityTagHeaderValue($"\"{operation.EntityVersion}\""));
+        }
+
+        using HttpResponseMessage response = await client.SendAsync(request, cancellationToken).ConfigureAwait(false);
+        return new ServiceResponse(response);
+    }
+}

src/CommunityToolkit.Datasync.Client/Offline/Internal/AddOperation.cs

@@ -0,0 +1,72 @@
+// 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.
+
+using CommunityToolkit.Datasync.Client.Service;
+using Microsoft.Extensions.Options;
+using System.Net;
+using System.Net.Http.Headers;
+using System.Text.Json;
+
+namespace CommunityToolkit.Datasync.Client.Offline.Internal;
+
+/// <summary>
+/// The abstract class that encapsulates all logic dealing with pushing an operation to the remote server.
+/// </summary>
+internal abstract class ExecutableOperation
+{
+    /// <summary>
+    /// The JSON media type.
+    /// </summary>
+    internal MediaTypeHeaderValue JsonMediaType { get; } = MediaTypeHeaderValue.Parse("application/json");
+
+    /// <summary>
+    /// Converts a base address + relative/absolute URI into the appropriate URI for the datasync service.
+    /// </summary>
+    /// <param name="baseAddress">The base address from the client.</param>
+    /// <param name="relativeOrAbsoluteUri">A relative or absolute URI</param>
+    /// <returns></returns>
+    internal static Uri MakeAbsoluteUri(Uri? baseAddress, Uri relativeOrAbsoluteUri)
+    {
+        if (relativeOrAbsoluteUri.IsAbsoluteUri)
+        {
+            return new Uri($"{relativeOrAbsoluteUri.ToString().TrimEnd('/')}/");
+        }
+
+        if (baseAddress != null)
+        {
+            if (baseAddress.IsAbsoluteUri)
+            {
+                return new Uri($"{new Uri(baseAddress, relativeOrAbsoluteUri).ToString().TrimEnd('/')}/");
+            }
+        }
+
+        throw new UriFormatException("Invalid combination of baseAddress and relativeUri");
+    }
+
+    /// <summary>
+    /// Performs the push operation, returning the result of the push operation.
+    /// </summary>
+    /// <param name="client">The <see cref="HttpClient"/> to use for communicating with the datasync service.</param>
+    /// <param name="endpoint">The fully-qualified URI to the table endpoint.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe.</param>
+    /// <returns>The result of the push operation (async).</returns>
+    internal abstract Task<ServiceResponse> ExecuteAsync(HttpClient client, Uri endpoint, CancellationToken cancellationToken = default);
+
+#pragma warning disable IDE0060 // Remove unused parameter - cancellationToken is kept for API consistency.
+    /// <summary>
+    /// Creates a new <see cref="ExecutableOperation"/> based on the operation model.
+    /// </summary>
+    /// <param name="operation">The operation to execute.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe.</param>
+    /// <returns>The <see cref="ExecutableOperation"/> to execute.</returns>
+    /// <exception cref="DatasyncException">If the operation Kind is not supported for push.</exception>
+    internal static Task<ExecutableOperation> CreateAsync(DatasyncOperation operation, CancellationToken cancellationToken = default) => operation.Kind switch
+    {
+        OperationKind.Add => Task.FromResult<ExecutableOperation>(new AddOperation(operation)),
+        OperationKind.Delete => Task.FromResult<ExecutableOperation>(new DeleteOperation(operation)),
+        OperationKind.Replace => Task.FromResult<ExecutableOperation>(new ReplaceOperation(operation)),
+        _ => throw new DatasyncException($"Invalid operation kind '{operation.Kind}'"),
+    };
+#pragma warning restore IDE0060 // Remove unused parameter
+}