Add support for TableEntity via ITableRepository and ITablePartition APIs

kzu · kzu · commit 5fc92b5b944a · 2021-05-29T19:36:30.000-03:00
Fixes #18
diff --git a/readme.md b/readme.md
@@ -55,7 +55,7 @@ var product = new Product("catId-asdf", "1234")
 await repo.PutAsync(product);
 
 // Enumerate all products in category "catId-asdf"
-await foreach (var p in repo.EnumerateAsync("catId-asdf")
+await foreach (var p in repo.EnumerateAsync("catId-asdf"))
    Console.WriteLine(p.Price);
 
 // Get previously saved product.
@@ -76,8 +76,8 @@ example. In such a case, instead of a `TableRepository`, you can use a `TablePar
 class Region 
 {
   public Region(string code, string name) 
-    => (Id, Amount)
-    = (id, amount);
+    => (Code, Name)
+    = (code, name);
 
   public string Code { get; }
 
@@ -87,20 +87,25 @@ class Region
 
 ```csharp
 var account = CloudStorageAccount.DevelopmentStorageAccount; // or production one
-// tableName will default to "Entity" and partition key to "Order", but they can 
+// We lay out the parameter names for clarity only.
 // also be provided to the factory method to override the default behavior.
-var repo = TablePartition.Create<Region>(storageAccount, region => region.Code);
+var repo = TablePartition.Create<Region>(storageAccount, 
+  // tableName defaults to "Entity" if not provided
+  tableName: "Reference",
+  // partitionKey would default to "Region" too if not provided
+  partitionKey: "Region",
+  rowKey: region => region.Code);
 
 var region = new Region("uk", "United Kingdom"); 
 
 // Insert or Update behavior (aka "upsert")
 await repo.PutAsync(region);
 
 // Enumerate all regions within the partition
-await foreach (var r in repo.EnumerateAsync()
+await foreach (var r in repo.EnumerateAsync())
    Console.WriteLine(r.Name);
 
-// Get previously saved order.
+// Get previously saved region.
 Region saved = await repo.GetAsync("uk");
 
 // Delete region
@@ -110,7 +115,7 @@ await repo.DeleteAsync("uk");
 await repo.DeleteAsync(saved);
 ```
 
-This is quite convenient for handing reference data, for example. Enumerating all entries 
+This is quite convenient for handling reference data, for example. Enumerating all entries 
 in the partition wouldn't be something you'd typically do for your "real" data, but for 
 reference data, it could be useful.
 
@@ -126,6 +131,30 @@ entity type to modify the default values used:
 Values passed to the `TableRepository.Create<T>` or `TablePartition.Create<T>` override 
 declarative attributes.
 
+### TableEntity Support
+
+Since these repository APIs are quite a bit more intuitive than working against a direct 
+`TableClient`, you might want to retrieve/enumerate entities just by their built-in `ITableEntity` 
+properties, like `PartitionKey`, `RowKey`, `Timestamp` and `ETag`. For this scenario, we 
+also support creating `ITableRepository<TableEntity>` and `ITablePartition<TableEntity>` 
+by using the factory methods `TableRepository.Create(...)` and `TablePartition.Create(...)` 
+without a (generic) entity type argument.
+
+For example, given you know all `Region` entities saved in the example above, use the region `Code` 
+as the `RowKey`, you could simply enumerate all regions without using the `Region` type at all:
+
+```csharp
+var account = CloudStorageAccount.DevelopmentStorageAccount; // or production one
+var repo = TablePartition.Create(storageAccount, 
+  tableName: "Reference",
+  partitionKey: "Region");
+
+// Enumerate all regions within the partition as plain TableEntities
+await foreach (TableEntity region in repo.EnumerateAsync())
+   Console.WriteLine(region.RowKey);
+```
+
+
 ## Installation
 
 ```
diff --git a/src/TableStorage/TableEntityPartition.cs b/src/TableStorage/TableEntityPartition.cs
@@ -0,0 +1,65 @@
+﻿//<auto-generated/>
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Azure.Cosmos.Table;
+
+namespace Devlooped
+{
+    /// <inheritdoc />
+    partial class TableEntityPartition : ITablePartition<TableEntity>
+    {
+        readonly ITableRepository<TableEntity> repository;
+
+        /// <summary>
+        /// Initializes the repository with the given storage account and optional table name.
+        /// </summary>
+        /// <param name="storageAccount">The <see cref="CloudStorageAccount"/> to use to connect to the table.</param>
+        /// <param name="tableName">The table that backs this table partition.</param>
+        /// <param name="partitionKey">The fixed partition key that backs this table partition.</param>
+        protected internal TableEntityPartition(CloudStorageAccount storageAccount, string tableName, string partitionKey)
+        {
+            TableName = tableName;
+            PartitionKey = partitionKey;
+            repository = new TableEntityRepository(storageAccount, TableName);
+        }
+
+        /// <inheritdoc />
+        public string TableName { get; }
+
+        /// <inheritdoc />
+        public string PartitionKey { get; }
+
+        /// <inheritdoc />
+        public async Task DeleteAsync(TableEntity entity, CancellationToken cancellation = default)
+        {
+            if (!PartitionKey.Equals(entity.PartitionKey, StringComparison.Ordinal))
+                throw new ArgumentException("Entity does not belong to the partition.");
+
+            await repository.DeleteAsync(entity, cancellation);
+        }
+
+        /// <inheritdoc />
+        public Task DeleteAsync(string rowKey, CancellationToken cancellation = default)
+            => repository.DeleteAsync(PartitionKey, rowKey, cancellation);
+
+        /// <inheritdoc />
+        public IAsyncEnumerable<TableEntity> EnumerateAsync(CancellationToken cancellation = default) 
+            => repository.EnumerateAsync(PartitionKey, cancellation);
+
+        /// <inheritdoc />
+        public Task<TableEntity?> GetAsync(string rowKey, CancellationToken cancellation = default)
+            => repository.GetAsync(PartitionKey, rowKey, cancellation);
+
+        /// <inheritdoc />
+        public async Task<TableEntity> PutAsync(TableEntity entity, CancellationToken cancellation = default)
+        {
+            if (!PartitionKey.Equals(entity.PartitionKey, StringComparison.Ordinal))
+                throw new ArgumentException("Entity does not belong to the partition.");
+
+            return await repository.PutAsync(entity, cancellation);
+        }
+    }
+}
diff --git a/src/TableStorage/TableEntityRepository.cs b/src/TableStorage/TableEntityRepository.cs
@@ -0,0 +1,107 @@
+﻿//<auto-generated/>
+#nullable enable
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Azure.Cosmos.Table;
+using Microsoft.Azure.Documents.SystemFunctions;
+
+namespace Devlooped
+{
+    /// <inheritdoc />
+    partial class TableEntityRepository : ITableRepository<TableEntity>
+    {
+        readonly CloudStorageAccount storageAccount;
+        readonly AsyncLazy<CloudTable> table;
+
+        /// <summary>
+        /// Initializes the table repository.
+        /// </summary>
+        /// <param name="storageAccount">The <see cref="CloudStorageAccount"/> to use to connect to the table.</param>
+        /// <param name="tableName">The table that backs this repository.</param>
+        protected internal TableEntityRepository(CloudStorageAccount storageAccount, string tableName)
+        {
+            this.storageAccount = storageAccount;
+            TableName = tableName;
+            table = new AsyncLazy<CloudTable>(() => GetTableAsync(TableName));
+        }
+
+        /// <inheritdoc />
+        public string TableName { get; }
+
+        /// <inheritdoc />
+        public async Task DeleteAsync(string partitionKey, string rowKey, CancellationToken cancellation = default)
+        {
+            var table = await this.table.Value.ConfigureAwait(false);
+
+            await table.ExecuteAsync(TableOperation.Delete(
+                new TableEntity(partitionKey, rowKey) { ETag = "*" }), cancellation)
+                .ConfigureAwait(false);
+        }
+
+        /// <inheritdoc />
+        public async Task DeleteAsync(TableEntity entity, CancellationToken cancellation = default)
+        {
+            var table = await this.table.Value.ConfigureAwait(false);
+            entity.ETag = "*";
+            await table.ExecuteAsync(TableOperation.Delete(entity), cancellation)
+                .ConfigureAwait(false);
+        }
+
+        /// <inheritdoc />
+        public async IAsyncEnumerable<TableEntity> EnumerateAsync(string partitionKey, [EnumeratorCancellation] CancellationToken cancellation = default)
+        {
+            var table = await this.table.Value;
+            var query = new TableQuery<TableEntity>()
+                .Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey));
+
+            TableContinuationToken? continuation = null;
+            do
+            {
+                var segment = await table.ExecuteQuerySegmentedAsync(query, continuation, cancellation)
+                    .ConfigureAwait(false);
+
+                foreach (var entity in segment)
+                    if (entity != null)
+                        yield return entity;
+
+            } while (continuation != null && !cancellation.IsCancellationRequested);
+        }
+
+        /// <inheritdoc />
+        public async Task<TableEntity?> GetAsync(string partitionKey, string rowKey, CancellationToken cancellation = default)
+        {
+            var table = await this.table.Value.ConfigureAwait(false);
+            var result = await table.ExecuteAsync(TableOperation.Retrieve(
+                partitionKey, rowKey,
+                (partitionKey, rowKey, timestamp, properties, etag) => new TableEntity(partitionKey, rowKey) { Timestamp = timestamp, ETag = etag }), 
+                cancellation)
+                .ConfigureAwait(false);
+
+            return (TableEntity?)result.Result;
+        }
+
+        /// <inheritdoc />
+        public async Task<TableEntity> PutAsync(TableEntity entity, CancellationToken cancellation = default)
+        {
+            var table = await this.table.Value.ConfigureAwait(false);
+            entity.ETag = "*";
+            var result = await table.ExecuteAsync(TableOperation.InsertOrReplace(entity), cancellation)
+                .ConfigureAwait(false);
+
+            return (TableEntity)result.Result;
+        }
+
+        async Task<CloudTable> GetTableAsync(string tableName)
+        {
+            var tableClient = storageAccount.CreateCloudTableClient();
+            var table = tableClient.GetTableReference(tableName);
+            await table.CreateIfNotExistsAsync();
+            return table;
+        }
+    }
+}
diff --git a/src/TableStorage/TablePartition.cs b/src/TableStorage/TablePartition.cs
@@ -18,6 +18,16 @@ static partial class TablePartition
         /// </summary>
         public const string DefaultTableName = "Entity";
 
+        /// <summary>
+        /// Creates an <see cref="ITablePartition{TableEntity}"/>, using 
+        /// <see cref="DefaultTableName"/> as the table name and the 
+        /// <typeparamref name="T"/> <c>Name</c> as the partition key.
+        /// </summary>
+        /// <param name="storageAccount">The storage account to use.</param>
+        /// <returns>The new <see cref="ITablePartition{TEntity}"/>.</returns>
+        public static ITablePartition<TableEntity> Create(CloudStorageAccount storageAccount, string tableName, string partitionKey)
+            => new TableEntityPartition(storageAccount, tableName, partitionKey);
+
         /// <summary>
         /// Creates an <see cref="ITablePartition{T}"/> for the given entity type 
         /// <typeparamref name="T"/>, using <see cref="DefaultTableName"/> as the table name and the 
diff --git a/src/TableStorage/TableRepository.cs b/src/TableStorage/TableRepository.cs
@@ -12,6 +12,17 @@ static partial class TableRepository
     {
         static readonly ConcurrentDictionary<Type, string> defaultTableNames = new();
 
+        /// <summary>
+        /// Creates an <see cref="ITableRepository{TableEntity}"/> repository.
+        /// </summary>
+        /// <param name="storageAccount">The storage account to use.</param>
+        /// <param name="tableName">Table name to use.</param>
+        /// <returns>The new <see cref="ITableRepository{TableEntity}"/>.</returns>
+        public static ITableRepository<TableEntity> Create(
+            CloudStorageAccount storageAccount,
+            string tableName)
+            => new TableEntityRepository(storageAccount, tableName);
+
         /// <summary>
         /// Creates an <see cref="ITableRepository{T}"/> for the given entity type 
         /// <typeparamref name="T"/>, using the <typeparamref name="T"/> <c>Name</c> as 
diff --git a/src/Tests/RepositoryTests.cs b/src/Tests/RepositoryTests.cs
@@ -101,6 +101,97 @@ public void DefaultTableNameUsesAttribute()
             Assert.Equal("Entities", TableRepository.Create<MyTableEntity>(CloudStorageAccount.DevelopmentStorageAccount).TableName);
         }
 
+        [Fact]
+        public async Task TableEntityEndToEnd()
+        {
+            var repo = TableRepository.Create(CloudStorageAccount.DevelopmentStorageAccount, "Entities");
+            var entity = await repo.PutAsync(new TableEntity("123", "Foo"));
+
+            Assert.Equal("123", entity.PartitionKey);
+            Assert.Equal("Foo", entity.RowKey);
+
+            var saved = await repo.GetAsync("123", "Foo");
+
+            Assert.NotNull(saved);
+            Assert.Equal(entity.RowKey, saved!.RowKey);
+
+            var entities = new List<TableEntity>();
+
+            await foreach (var e in repo.EnumerateAsync("123"))
+                entities.Add(e);
+
+            Assert.Single(entities);
+
+            await repo.DeleteAsync(saved);
+
+            Assert.Null(await repo.GetAsync("123", "Foo"));
+
+            await foreach (var _ in repo.EnumerateAsync("123"))
+                Assert.False(true, "Did not expect to find any entities");
+        }
+
+        [Fact]
+        public async Task TableEntityPartitionEndToEnd()
+        {
+            var partition = TablePartition.Create(CloudStorageAccount.DevelopmentStorageAccount, "Entities", "Watched");
+
+            // Entity PartitionKey does not belong to the partition
+            await Assert.ThrowsAsync<ArgumentException>(async () => await partition.PutAsync(new TableEntity("123", "Foo")));
+            await Assert.ThrowsAsync<ArgumentException>(async () => await partition.DeleteAsync(new TableEntity("123", "Foo")));
+
+            var entity = await partition.PutAsync(new TableEntity("Watched", "123"));
+
+            Assert.Equal("Watched", entity.PartitionKey);
+            Assert.Equal("123", entity.RowKey);
+
+            var saved = await partition.GetAsync("123");
+
+            Assert.NotNull(saved);
+            Assert.Equal(entity.RowKey, saved!.RowKey);
+
+            var entities = new List<TableEntity>();
+
+            await foreach (var e in partition.EnumerateAsync())
+                entities.Add(e);
+
+            Assert.Single(entities);
+
+            await partition.DeleteAsync(saved);
+
+            Assert.Null(await partition.GetAsync("123"));
+
+            await foreach (var _ in partition.EnumerateAsync())
+                Assert.False(true, "Did not expect to find any entities");
+        }
+
+        [Fact]
+        public async Task CanEnumerateEntities()
+        {
+            await CloudStorageAccount.DevelopmentStorageAccount.CreateCloudTableClient().GetTableReference(nameof(CanEnumerateEntities))
+                .DeleteIfExistsAsync();
+
+            var partition = TablePartition.Create<MyEntity>(CloudStorageAccount.DevelopmentStorageAccount, nameof(CanEnumerateEntities), "Watched");
+
+            await partition.PutAsync(new MyEntity("123") { Name = "Foo" });
+            await partition.PutAsync(new MyEntity("456") { Name = "Bar" });
+
+            var count = 0;
+            await foreach (var entity in partition.EnumerateAsync())
+                count++;
+
+            Assert.Equal(2, count);
+
+            var generic = TablePartition.Create(CloudStorageAccount.DevelopmentStorageAccount, nameof(CanEnumerateEntities), "Watched");
+
+            await generic.PutAsync(new TableEntity("Watched", "789"));
+
+            await foreach (var entity in generic.EnumerateAsync())
+            {
+                Assert.Equal("Watched", entity.PartitionKey);
+                Assert.NotNull(entity.RowKey);
+            }
+        }
+
         class MyEntity
         {
             public MyEntity(string id) => Id = id;
