Feature/custom table name mapping

Dapper.GraphQL.Test/DeleteTests.cs

@@ -0,0 +1,25 @@
+using Dapper.GraphQL.Test.Models;
+using Xunit;
+
+namespace Dapper.GraphQL.Test
+{
+    public class DeleteTests : IClassFixture<TestFixture>
+    {
+        private readonly TestFixture fixture;
+
+        public DeleteTests(TestFixture fixture)
+        {
+            this.fixture = fixture;
+        }
+
+        [Fact(DisplayName = "DELETE query uses custom table name")]
+        public void DeleteWithCustomTableName()
+        {
+            // Check generic Delete uses custom table name for Contact as configured in TestFixture
+            var contact = new Contact();
+
+            var query = SqlBuilder.Delete<Contact>(contact);
+            Assert.Equal("DELETE FROM Contacts WHERE ", query.ToString());
+        }
+    }
+}

Dapper.GraphQL.Test/InsertTests.cs

@@ -53,8 +53,7 @@ public void InsertPerson()
                 };
 
                 // Add email and phone number to the person
-                int insertedCount;
-                insertedCount = SqlBuilder
+                var insertedCount = SqlBuilder
                     .Insert(email)
                     .Insert(phone)
                     .Execute(db);
@@ -153,8 +152,7 @@ public async Task InsertPersonAsync()
                 };
 
                 // Add email and phone number to the person
-                int insertedCount;
-                insertedCount = await SqlBuilder
+                var insertedCount = await SqlBuilder
                     .Insert(email)
                     .Insert(phone)
                     .ExecuteAsync(db);
@@ -210,5 +208,16 @@ public async Task InsertPersonAsync()
             Assert.Equal("8011115555", person.Phones[0].Number);
             Assert.Equal(personId, person.Phones[0].PersonId);
         }
+
+        [Fact(DisplayName = "INSERT query uses custom table name")]
+        public void InsertWithCustomTableName()
+        {
+            // Check generic Insert uses custom table name for Contact as configured in TestFixture
+            var contact = new Contact();
+            var query = SqlBuilder.Insert<Contact>(contact);
+
+            Assert.Equal("Contacts", query.Table);
+            Assert.Equal("INSERT INTO Contacts () VALUES ();", query.ToString());
+        }
     }
 }

Dapper.GraphQL.Test/Models/Contact.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Dapper.GraphQL.Test.Models
+{
+    public class Contact
+    {
+
+    }
+}

Dapper.GraphQL.Test/QueryTests.cs

@@ -48,5 +48,18 @@ public void SelectWithoutMatchingAliasShouldThrow()
                 }
             });
         }
+
+        [Fact(DisplayName = "SELECT query uses custom table name")]
+        public void SelectWithCustomTableName()
+        {
+            // Check generic Select uses custom table name for Contact as configured in TestFixture
+            var contact = new Contact();
+
+            var query = SqlBuilder.From<Contact>();
+            Assert.Equal("SELECT\r\n\r\nFROM Contacts\r\n", query.ToString());
+
+            var queryWithAlias = SqlBuilder.From<Contact>("contacts");
+            Assert.Equal("SELECT\r\n\r\nFROM Contacts contacts\r\n", queryWithAlias.ToString());
+        }
     }
 }

Dapper.GraphQL.Test/TestFixture.cs

@@ -192,6 +192,9 @@ private void SetupDapperGraphQL(IServiceCollection serviceCollection)
 
                 // Add entity mappers
                 options.AddEntityMapper<Person, PersonEntityMapper>();
+
+                // Configure custom table names
+                options.AddCustomTableNameMapping<Contact>("Contacts"); 
             });
         }
 

Dapper.GraphQL.Test/UpdateTests.cs

@@ -150,5 +150,15 @@ await SqlBuilder
                 }
             }
         }
+
+        [Fact(DisplayName = "UPDATE query uses custom table name")]
+        public void UpdateWithCustomTableName()
+        {
+            // Check generic Update uses custom table name for Contact as configured in TestFixture
+            var contact = new Contact();
+
+            var query = SqlBuilder.Update<Contact>(contact);
+            Assert.Equal("UPDATE Contacts SET \r\n", query.ToString());
+        }
     }
 }

Dapper.GraphQL/Contexts/SqlDeleteContext.cs

@@ -27,7 +27,7 @@ public SqlDeleteContext(
 
         public static SqlDeleteContext Delete<TEntityType>(dynamic parameters = null)
         {
-            return new SqlDeleteContext(typeof(TEntityType).Name, parameters);
+            return new SqlDeleteContext(TableHelper.GetTableName<TEntityType>(), parameters);
         }
 
         /// <summary>

Dapper.GraphQL/Contexts/SqlQueryContext.cs

@@ -9,8 +9,8 @@ namespace Dapper.GraphQL
 {
     public class SqlQueryContext<TEntityType> : SqlQueryContext
     {
-        public SqlQueryContext(string alias = null, dynamic parameters = null)
-            : base(alias == null ? typeof(TEntityType).Name : $"{typeof(TEntityType).Name} {alias}")
+        public SqlQueryContext(string alias = null) :
+            base(alias == null ? TableHelper.GetTableName<TEntityType>() : $"{TableHelper.GetTableName<TEntityType>()} {alias}")
         {
             _types.Add(typeof(TEntityType));
         }

Dapper.GraphQL/DapperGraphQLOptions.cs

@@ -63,5 +63,18 @@ public DapperGraphQLOptions AddType<TGraphType>() where TGraphType : class, IGra
             serviceCollection.AddSingleton<TGraphType>();
             return this;
         }
+
+        /// <summary>
+        /// Configures a custom table name to use for <typeparamref name="TEntity"/>
+        /// when auto-mapping to a SQL table name.
+        /// </summary>
+        /// <typeparam name="TEntity">The model type to be mapped.</typeparam>
+        /// <param name="tableName">The custom table name to set.</param>
+        /// <returns></returns>
+        public DapperGraphQLOptions AddCustomTableNameMapping<TEntity>(string tableName) where TEntity : class
+        {
+            TableHelper.AddCustomTableNameMapping<TEntity>(tableName);
+            return this;
+        }
     }
 }

Dapper.GraphQL/SqlBuilder.cs

@@ -20,7 +20,7 @@ public static SqlDeleteContext Delete(string from, dynamic parameters = null)
 
         public static SqlDeleteContext Delete<TEntityType>(dynamic parameters = null)
         {
-            return new SqlDeleteContext(typeof(TEntityType).Name, parameters);
+            return new SqlDeleteContext(TableHelper.GetTableName<TEntityType>(), parameters);
         }
 
         public static SqlQueryContext From(string from, dynamic parameters = null)
@@ -35,7 +35,7 @@ public static SqlQueryContext From<TEntityType>(string alias = null)
 
         public static SqlInsertContext<TEntityType> Insert<TEntityType>(TEntityType obj)
         {
-            return new SqlInsertContext<TEntityType>(typeof(TEntityType).Name, obj);
+            return new SqlInsertContext(TableHelper.GetTableName<TEntityType>(), obj);
         }
 
         public static SqlInsertContext Insert(string table, dynamic parameters = null)
@@ -45,7 +45,7 @@ public static SqlInsertContext Insert(string table, dynamic parameters = null)
 
         public static SqlUpdateContext Update<TEntityType>(TEntityType obj)
         {
-            return new SqlUpdateContext(typeof(TEntityType).Name, obj);
+            return new SqlUpdateContext(TableHelper.GetTableName<TEntityType>(), obj);
         }
 
         public static SqlUpdateContext Update(string table, dynamic parameters = null)

Dapper.GraphQL/TableHelper.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+
+namespace Dapper.GraphQL
+{
+    /// <summary>
+    /// Helper for table related operations.
+    /// </summary>
+    public static class TableHelper
+    {
+        private static Dictionary<Type, string> TableNameCache = new Dictionary<Type, string>();
+
+        /// <summary>
+        /// Gets a table name for a given type, as configured with a default.
+        /// </summary>
+        /// <typeparam name="TEntity">The type to get a table name for.</typeparam>
+        /// <returns>The configured table name or a generated default.</returns>
+        public static string GetTableName<TEntity>()
+        {
+            var type = typeof(TEntity);
+            if (!TableNameCache.ContainsKey(type))
+            {
+                lock (TableNameCache)
+                {
+                    if (!TableNameCache.ContainsKey(type))
+                    {
+                        // Generate a default and cache it
+                        TableNameCache[type] = type.Name;
+                    }
+                    else
+                    {
+                        return TableNameCache[type];
+                    }
+                }
+            }
+
+            return TableNameCache[type];
+        }
+
+        public static void AddCustomTableNameMapping<TEntity>(string name)
+        {
+            var type = typeof(TEntity);
+            if (TableNameCache.TryGetValue(type, out string tableName) && tableName != name)
+            {
+                throw new InvalidOperationException($"Dapper.GraphQL - Cannot add multiple custom table names for type '${type.Name}'");
+            }
+            else
+            {
+                lock (TableNameCache)
+                {
+                    TableNameCache[type] = name;
+                }
+            }
+        }
+    }
+}