✨feat: ValueTuple support for Entity methods

Added ValueTuple support in Entity methods for Get & List. The methods can now
be used as ListAsync<(TypeA, TypeB)> with up to seven elements.

Author: lukaferlez

src/Simpleverse.Repository.Db.Test/SqlServer/Entity/EntityTest.cs

@@ -0,0 +1,96 @@
+using Dapper.Contrib.Extensions;
+using System.Linq;
+using Simpleverse.Repository.Db.Extensions;
+using Simpleverse.Repository.Db.Extensions.Dapper;
+using Xunit;
+using Xunit.Abstractions;
+using System;
+
+namespace Simpleverse.Repository.Db.Test.SqlServer.Entity
+{
+	[Collection("SqlServerCollection")]
+	public class EntityTest : TestFixture
+	{
+		public EntityTest(DatabaseFixture fixture, ITestOutputHelper output)
+			: base(fixture, output)
+		{
+
+		}
+
+		[Fact]
+		public void ListAsyncTupleTest()
+		{
+			using (var profiler = Profile())
+			using (var connection = _fixture.GetConnection())
+			{
+				// arange
+				connection.Open();
+				connection.Truncate<Identity>();
+				connection.Truncate<ExplicitKey>();
+				var explicitKeyRecords = TestData.ExplicitKeyData(10);
+				var identityRecords = TestData.IdentityWithIdData(10);
+
+				connection.Insert(explicitKeyRecords);
+				connection.Insert(identityRecords);
+
+				var entity = new IdentityEntity(_fixture);
+
+				// act
+				var records = entity.ListAsync<(Identity identity, ExplicitKey explicitKey)>().Result;
+
+				// assert
+				Assert.Equal(10, records.Count());
+				foreach (var record in records)
+				{
+					Assert.NotEqual(0, record.identity.Id);
+					Assert.NotEqual(0, record.explicitKey.Id);
+				}
+			}
+		}
+
+		[Fact]
+		public void ListAsyncTupleFailTest()
+		{
+			var entity = new IdentityEntity(_fixture);
+
+			// act
+			var exception = Assert.Throws<NotSupportedException>(
+					() => entity.ListAsync<(
+						Identity identity1,
+						Identity identity2,
+						Identity identity3,
+						Identity identity4,
+						Identity identity5,
+						Identity identity6,
+						Identity identity7,
+						Identity identity8
+					) >().Result
+				);
+
+			Assert.Equal("Number of Tuple arguments is more than the supported 7.", exception.Message);
+		}
+	}
+
+	public class IdentityEntity : Entity<Identity, QueryFilter, DbQueryOptions>
+	{
+		public IdentityEntity(DatabaseFixture fixture)
+			: base(new DbRepository(() => fixture.GetConnection()), new Table<Identity>("I"))
+		{
+		}
+
+		protected override void SelectQuery(QueryBuilder<Identity> builder, QueryFilter filter, DbQueryOptions options)
+		{
+			var explicitKey = new Table<ExplicitKey>("EK");
+
+			builder.SelectAll(explicitKey);
+
+			builder.Join(
+				explicitKey,
+				i => i.Id,
+				ek => ek.Id
+			);
+
+			base.SelectQuery(builder, filter, options);
+		}
+	}
+}

src/Simpleverse.Repository.Db/DbRepository.cs

@@ -74,6 +74,11 @@ public async Task<IEnumerable<dynamic>> QueryAsync(string rawSql, object paramet
 			return await ExecuteAsync((conn, tran) => conn.QueryAsync<TFirst, TSecond, TThird, TFourth, TFifth, TSixth, (TFirst, TSecond, TThird, TFourth, TFifth, TSixth)>(rawSql, (first, second, third, fourth, fifth, sixth) => (first, second, third, fourth, fifth, sixth), param: parameters, transaction: tran));
 		}
 
+		public async Task<IEnumerable<(TFirst, TSecond, TThird, TFourth, TFifth, TSixth, TSeventh)>> QueryAsync<TFirst, TSecond, TThird, TFourth, TFifth, TSixth, TSeventh>(string rawSql, object parameters)
+		{
+			return await ExecuteAsync((conn, tran) => conn.QueryAsync<TFirst, TSecond, TThird, TFourth, TFifth, TSixth, TSeventh, (TFirst, TSecond, TThird, TFourth, TFifth, TSixth, TSeventh)>(rawSql, (first, second, third, fourth, fifth, sixth, seventh) => (first, second, third, fourth, fifth, sixth, seventh), param: parameters, transaction: tran));
+		}
+
 		public async Task<int> ExecuteAsync(SqlBuilder.Template query)
 		{
 			return await ExecuteAsync((conn, tran) => conn.ExecuteAsync(query.RawSql, param: query.Parameters, transaction: tran));

src/Simpleverse.Repository.Db/Entity.cs

@@ -102,7 +102,23 @@ public virtual Task<IEnumerable<T>> ListAsync<T>(TFilter filter, TOptions option
 			var builder = Source.AsQuery();
 			SelectQuery(builder, filter, options);
 
+			var type = typeof(T);
+
 			var query = SelectTemplate(builder, options);
+			if (type.Name.StartsWith("ValueTuple`"))
+			{
+				var typeArguments = type.GenericTypeArguments;
+				var typeArgumentsCount = typeArguments.Count();
+				if (typeArgumentsCount > 7)
+					throw new NotSupportedException("Number of Tuple arguments is more than the supported 7.");
+
+				return (Task<IEnumerable<T>>) Repository
+					.GetType()
+					.GetMethod(nameof(Repository.QueryAsync), typeArgumentsCount, new[] { query.GetType() } )
+					.MakeGenericMethod(type.GenericTypeArguments)
+					.Invoke(Repository, new[] { query });
+			}
+			
 			return Repository.QueryAsync<T>(query);
 		}
 

src/Simpleverse.Repository.Db/Simpleverse.Repository.Db.csproj

@@ -13,10 +13,10 @@
     <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
     <PackageTags>Dapper, Bulk, Merge, Upsert, Delete, Insert, Update, Repository</PackageTags>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
-    <Version>2.0.19</Version>
+    <Version>2.0.20</Version>
     <Description>High performance operation for MS SQL Server built for Dapper ORM. Including bulk operations Insert, Update, Delete, Get as well as Upsert both single and bulk.</Description>
-    <AssemblyVersion>2.0.19</AssemblyVersion>
-    <FileVersion>2.0.19</FileVersion>
+    <AssemblyVersion>2.0.20</AssemblyVersion>
+    <FileVersion>2.0.20</FileVersion>
     <RepositoryUrl>https://github.com/lukaferlez/Simpleverse.Repository</RepositoryUrl>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <EmbedAllSources>true</EmbedAllSources>