Add INamingStrategy for implicit property names

quinchs · quinchs · commit 148488fd52b4 · 2022-06-13T21:53:37.000-03:00
diff --git a/docs/configuring.rst b/docs/configuring.rst
@@ -40,4 +40,16 @@ with the ``EdgeDBConfig`` class like so:
     - The amount of miliseconds to wait for a message to be received. 
   * - RetryMode
     -  ``ConnectionRetryMode``
-    - The retry mode for when a connection can't be established 
+    - The retry mode for when a connection can't be established 
+  * - ExplicitObjectIds
+    - ``bool``
+    - Whether or not to always return object ids.
+  * - ImplicitTypeNames
+    - ``bool``
+    - Whether or not to implicitly return type names.
+  * - ImplicitTypeIds
+    - ``bool`` 
+    - Whether or not to implicitly return type ids.
+  * - SerializerNamingStrategy
+    - ``INamingStrategy`` 
+    - The default naming strategy for the type builder.
diff --git a/docs/datatypes.rst b/docs/datatypes.rst
@@ -74,18 +74,18 @@ We can write at class that represents person as follows:
 
   public class Person
   {
-    [EdgeDBProperty("name")]
     public string? Name { get; set; }
     
-    [EdgeDBProperty("email")]
     public string? Email { get; set; }
   }
 
 .. note:: 
 
-  Since the naming convention of properties is diffent from the EdgeDB naming convention,
-  you can specify the name with the ``EdgeDBProperty`` attribute. You can also specify 
-  the name of the type with the ``EdgeDBType`` attribute.
+  Since the naming convention of properties is diffent from the EdgeDB naming convention, 
+  The class responsible for deserializing the schema type will use a ``INamingStrategy`` 
+  to map the EdgeDB properties to the dotnet properties. You can change the default naming 
+  strategy in the config. You can also specify the name with the ``EdgeDBProperty`` attribute. 
+  You can also specify the name of the type with the ``EdgeDBType`` attribute.
 
 You can find an example with custom types `here <https://github.com/quinchs/EdgeDB.Net/blob/dev/examples/EdgeDB.ExampleApp/Examples/QueryResults.cs>`_
 
diff --git a/examples/EdgeDB.Examples.ExampleApp/Examples/CustomDeserializer.cs b/examples/EdgeDB.Examples.ExampleApp/Examples/CustomDeserializer.cs
@@ -1,4 +1,5 @@
-﻿using Microsoft.Extensions.Logging;
+﻿using EdgeDB.Serializer;
+using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
 using System.Linq;
diff --git a/examples/EdgeDB.Examples.ExampleApp/Examples/QueryResults.cs b/examples/EdgeDB.Examples.ExampleApp/Examples/QueryResults.cs
@@ -23,10 +23,7 @@ public class QueryResults : IExample
         // We have a type called 'Person' with a few properties, we can create a class that resembles this object like so
         public class Person
         {
-            [EdgeDBProperty("name")]
             public string? Name { get; set; }
-
-            [EdgeDBProperty("email")]
             public string? Email { get; set; }
         }
 
diff --git a/examples/EdgeDB.Examples.ExampleApp/Program.cs b/examples/EdgeDB.Examples.ExampleApp/Program.cs
@@ -20,14 +20,7 @@
             loggingBuilder.AddSerilog(dispose: true);
         });
 
-        services.AddSingleton((provider) =>
-        {
-            return new EdgeDBClient(new EdgeDBClientPoolConfig
-            {
-                Logger = provider.GetService<ILoggerFactory>()!.CreateLogger("EdgeDB"),
-                ExplicitObjectIds = true,
-            });
-        });
+        services.AddEdgeDB();
 
         services.AddSingleton<ExampleRunner>();
     }).Build();
diff --git a/src/EdgeDB.Net.Driver/EdgeDBConfig.cs b/src/EdgeDB.Net.Driver/EdgeDBConfig.cs
@@ -1,4 +1,5 @@
-﻿using Microsoft.Extensions.Logging;
+﻿using EdgeDB.Serializer;
+using Microsoft.Extensions.Logging;
 
 namespace EdgeDB
 {
@@ -105,5 +106,17 @@ public class EdgeDBConfig
         ///     (equivalent to having an implicit “__tid__ := .__type__.id” computed property.)
         /// </remarks>
         public bool ImplicitTypeIds { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the default naming strategy for the type builder.
+        /// </summary>
+        /// <remarks>
+        /// See <seealso cref="TypeBuilder.NamingStrategy"/>
+        /// </remarks>
+        public INamingStrategy SerializerNamingStrategy
+        {
+            get => TypeBuilder.NamingStrategy;
+            set => TypeBuilder.NamingStrategy = value;
+        }
     }
 }
diff --git a/src/EdgeDB.Net.Driver/Extensions/EdgeDBHostingExtensions.cs b/src/EdgeDB.Net.Driver/Extensions/EdgeDBHostingExtensions.cs
@@ -1,4 +1,5 @@
 ﻿using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -13,12 +14,21 @@ public static IServiceCollection AddEdgeDB(this IServiceCollection collection, E
             Action<EdgeDBClientPoolConfig>? configure = null)
         {
             var conn = connection ?? EdgeDBConnection.ResolveConnection();
-            var config = new EdgeDBClientPoolConfig();
-            configure?.Invoke(config);
 
             collection.AddSingleton(conn);
-            collection.AddSingleton(config);
+            collection.AddSingleton<EdgeDBClientPoolConfig>((provider) =>
+            {
+                var config = new EdgeDBClientPoolConfig();
+                configure?.Invoke(config);
+
+                if (config.Logger is null)
+                {
+                    config.Logger = provider.GetService<ILoggerFactory>()?.CreateLogger("EdgeDB");
+                }
+                return config;
+            });
             collection.AddSingleton<EdgeDBClient>();
+
             return collection;
         }
     }
diff --git a/src/EdgeDB.Net.Driver/Serializer/SchemaTypeBuilders/NamingStrategies/AttributeNamingStrategy.cs b/src/EdgeDB.Net.Driver/Serializer/SchemaTypeBuilders/NamingStrategies/AttributeNamingStrategy.cs
@@ -0,0 +1,17 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace EdgeDB.Serializer
+{
+    public sealed class AttributeNamingStrategy : INamingStrategy
+    {
+        public string GetName(PropertyInfo property)
+        {
+            return property.GetCustomAttribute<EdgeDBPropertyAttribute>()?.Name ?? property.Name;
+        }
+    }
+}
diff --git a/src/EdgeDB.Net.Driver/Serializer/SchemaTypeBuilders/NamingStrategies/CamelCaseNamingStrategy.cs b/src/EdgeDB.Net.Driver/Serializer/SchemaTypeBuilders/NamingStrategies/CamelCaseNamingStrategy.cs
@@ -0,0 +1,18 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace EdgeDB.Serializer
+{
+    public sealed class CamelCaseNamingStrategy : INamingStrategy
+    {
+        public string GetName(PropertyInfo property)
+        {
+            var name = property.Name;
+            return $"{char.ToLowerInvariant(name[0])}{name[1..].Replace("_", string.Empty)}";
+        }
+    }
+}
diff --git a/src/EdgeDB.Net.Driver/Serializer/SchemaTypeBuilders/NamingStrategies/INamingStrategy.cs b/src/EdgeDB.Net.Driver/Serializer/SchemaTypeBuilders/NamingStrategies/INamingStrategy.cs
@@ -0,0 +1,50 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace EdgeDB.Serializer
+{
+    /// <summary>
+    ///     Represents an abstract naming strategy used to convert property names within 
+    ///     a dotnet type to a name within a schema file.
+    /// </summary>
+    public interface INamingStrategy
+    {
+        /// <summary>
+        ///     Gets the attribute-based naming strategy.
+        /// </summary>
+        public static INamingStrategy AttributeNamingStrategy
+            => new AttributeNamingStrategy();
+
+        /// <summary>
+        ///     Gets the 'camelCase' naming strategy.
+        /// </summary>
+        public static INamingStrategy CamelCaseNamingStrategy
+            => new CamelCaseNamingStrategy();
+
+        /// <summary>
+        ///     Gets the 'PascalCase' naming strategy.
+        /// </summary>
+        public static INamingStrategy PascalNamingStrategy
+            => new PascalNamingStrategy();
+
+        /// <summary>
+        ///     Gets the 'snake-case' naming strategy.
+        /// </summary>
+        /// <remarks>
+        ///     This is the default naming strategy for the <see cref="TypeBuilder"/>.
+        /// </remarks>
+        public static INamingStrategy SnakeCaseNamingStrategy
+            => new SnakeCaseNamingStrategy();
+
+        /// <summary>
+        ///     Gets the name defined in the objects schema given the types property info.
+        /// </summary>
+        /// <param name="property">The property info of which to convert its name.</param>
+        /// <returns>The name defined in the schema.</returns>
+        public string GetName(PropertyInfo property);
+    }
+}
diff --git a/src/EdgeDB.Net.Driver/Serializer/SchemaTypeBuilders/NamingStrategies/PascalNamingStrategy.cs b/src/EdgeDB.Net.Driver/Serializer/SchemaTypeBuilders/NamingStrategies/PascalNamingStrategy.cs
@@ -0,0 +1,27 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace EdgeDB.Serializer
+{
+    public sealed class PascalNamingStrategy : INamingStrategy
+    {
+        public string GetName(PropertyInfo property)
+        {
+            var str = property.Name;
+
+            string sample = string.Join("", str.Select(c => Char.IsLetterOrDigit(c) ? c.ToString().ToLower() : "_").ToArray());
+            
+            var arr = sample
+                .Split(new[] { '_' }, StringSplitOptions.RemoveEmptyEntries)
+                .Select(s => $"{s.Substring(0, 1).ToUpper()}{s.Substring(1)}");
+
+            sample = string.Join("", arr);
+
+            return sample;
+        }
+    }
+}
diff --git a/src/EdgeDB.Net.Driver/Serializer/SchemaTypeBuilders/NamingStrategies/SnakeCaseNamingStrategy.cs b/src/EdgeDB.Net.Driver/Serializer/SchemaTypeBuilders/NamingStrategies/SnakeCaseNamingStrategy.cs
@@ -0,0 +1,18 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace EdgeDB.Serializer
+{
+    public sealed class SnakeCaseNamingStrategy : INamingStrategy
+    {
+        public string GetName(PropertyInfo property)
+        {
+            return Regex.Replace(property.Name, "(?<!^)[A-Z]", x => $"_{x.Value}").ToLower();
+        }
+    }
+}
diff --git a/src/EdgeDB.Net.Driver/Serializer/SchemaTypeBuilders/ObjectBuilder.cs b/src/EdgeDB.Net.Driver/Serializer/SchemaTypeBuilders/ObjectBuilder.cs
@@ -1,7 +1,7 @@
-﻿using System.Collections;
+﻿using EdgeDB.Serializer;
+using System.Collections;
 using System.Collections.Concurrent;
 using System.Reflection;
-using System.Reflection.Emit;
 
 namespace EdgeDB
 {
@@ -30,6 +30,12 @@ internal class ObjectBuilder
             if (valueType.IsAssignableTo(type))
                 return value;
 
+            // check for enums
+            if(value is string str && type.IsEnum)
+            {
+                return Enum.Parse(type, str);
+            }
+
             // check for arrays or sets
             if (valueType.IsArray || valueType.IsAssignableTo(typeof(IEnumerable)))
             {
diff --git a/src/EdgeDB.Net.Driver/Serializer/SchemaTypeBuilders/TypeBuilder.cs b/src/EdgeDB.Net.Driver/Serializer/SchemaTypeBuilders/TypeBuilder.cs
@@ -3,15 +3,33 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 
-namespace EdgeDB
+namespace EdgeDB.Serializer
 {
     /// <summary>
     ///     Represents the class used to build types from edgedb query results.
     /// </summary>
     public static class TypeBuilder
     {
+        /// <summary>
+        ///     Gets or sets the naming strategy used when mapping type names returned 
+        ///     from EdgeDB to C# classes.
+        /// </summary>
+        /// <remarks>
+        ///     If the naming strategy doesn't find a match, the 
+        ///     <see cref="AttributeNamingStrategy"/> will be used.
+        /// </remarks>
+        public static INamingStrategy NamingStrategy { get; set; }
+
         internal static ConcurrentDictionary<Type, Func<IDictionary<string, object?>, object>> _typeInfo = new();
 
+        private static readonly INamingStrategy _attributeNamingStrategy;
+
+        static TypeBuilder()
+        {
+            _attributeNamingStrategy = INamingStrategy.AttributeNamingStrategy;
+            NamingStrategy ??= INamingStrategy.SnakeCaseNamingStrategy;
+        }
+
         /// <summary>
         ///     Adds or updates a custom type builder.
         /// </summary>
@@ -135,26 +153,28 @@ internal static bool TryGetCollectionParser(Type type, out Func<Array, Type, obj
 
                 foreach (var prop in propertyMap)
                 {
-                    if (data.TryGetValue(prop.Key, out var value))
+                    var foundProperty = data.TryGetValue(NamingStrategy.GetName(prop), out object? value) || data.TryGetValue(_attributeNamingStrategy.GetName(prop), out value);
+
+                    if (!foundProperty || value is null)
+                        continue;
+
+                    var valueType = value?.GetType();
+
+                    if (valueType == null)
+                        continue;
+
+                    if (valueType.IsAssignableTo(prop.PropertyType))
                     {
-                        var valueType = value?.GetType();
-
-                        if (valueType == null)
-                            continue;
-
-                        if (valueType.IsAssignableTo(prop.Value.PropertyType))
-                        {
-                            prop.Value.SetValue(instance, value);
-                            continue;
-                        }
-                        else if (prop.Value.PropertyType.IsEnum && value is string str) // enums
-                        {
-                            prop.Value.SetValue(instance, Enum.Parse(prop.Value.PropertyType, str));
-                            continue;
-                        }
-
-                        prop.Value.SetValue(instance, prop.Value.PropertyType.ConvertValue(value));
+                        prop.SetValue(instance, value);
+                        continue;
                     }
+                    else if (prop.PropertyType.IsEnum && value is string str) // enums
+                    {
+                        prop.SetValue(instance, Enum.Parse(prop.PropertyType, str));
+                        continue;
+                    }
+
+                    prop.SetValue(instance, prop.PropertyType.ConvertValue(value));
                 }
 
                 return instance;
@@ -226,16 +246,12 @@ internal static bool TryGetCustomBuilder(this Type objectType, out MethodInfo? i
             return method is not null;
         }
 
-        internal static Dictionary<string, PropertyInfo> GetPropertyMap(this Type objectType)
+        internal static IEnumerable<PropertyInfo> GetPropertyMap(this Type objectType)
         {
-            var properties = objectType.GetProperties().Where(x =>
+            return objectType.GetProperties().Where(x =>
                 x.CanWrite &&
                 x.GetCustomAttribute<EdgeDBIgnoreAttribute>() == null &&
                 x.SetMethod != null);
-
-            return properties.ToDictionary(
-                x => x.GetCustomAttribute<EdgeDBPropertyAttribute>()?.Name ?? x.Name,
-                x => x);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -23,10 +23,7 @@ public class QueryResults : IExample`
`23`	`23`	`// We have a type called 'Person' with a few properties, we can create a class that resembles this object like so`
`24`	`24`	`public class Person`
`25`	`25`	`{`
`26`		`- [EdgeDBProperty("name")]`
`27`	`26`	`public string? Name { get; set; }`
`28`		`-`
`29`		`- [EdgeDBProperty("email")]`
`30`	`27`	`public string? Email { get; set; }`
`31`	`28`	`}`
`32`	`29`