Fixes parsing issue described in #12 and added unit tests

src/Venflow/Venflow.Tests/SpecificTypes/CLREnumTests.cs

@@ -6,6 +6,40 @@ namespace Venflow.Tests.SpecificTypes
 {
     public class CLREnumTests : TestBase
     {
+        [Fact]
+        public async Task Query()
+        {
+            var dummy = new UncommonType
+            {
+                CLREnum = DummyEnum.Foo
+            };
+
+            Assert.Equal(1, await Database.UncommonTypes.InsertAsync(dummy));
+
+            dummy = await Database.UncommonTypes.QueryInterpolatedSingle($@"SELECT * FROM ""UncommonTypes"" WHERE ""CLREnum"" = {dummy.CLREnum}").Build().QueryAsync();
+
+            Assert.Equal(DummyEnum.Foo, dummy.CLREnum);
+
+            await Database.UncommonTypes.DeleteAsync(dummy);
+        }
+
+        [Fact]
+        public async Task QueryNullableValue()
+        {
+            var dummy = new UncommonType
+            {
+                NCLREnum = DummyEnum.Foo
+            };
+
+            Assert.Equal(1, await Database.UncommonTypes.InsertAsync(dummy));
+
+            dummy = await Database.UncommonTypes.QueryInterpolatedSingle($@"SELECT * FROM ""UncommonTypes"" WHERE ""NCLREnum"" = {dummy.NCLREnum}").Build().QueryAsync();
+
+            Assert.Equal(DummyEnum.Foo, dummy.NCLREnum);
+
+            await Database.UncommonTypes.DeleteAsync(dummy);
+        }
+
         [Fact]
         public async Task Insert()
         {

src/Venflow/Venflow/CastTypeHandler.cs

@@ -0,0 +1,10 @@
+using Npgsql;
+
+namespace Venflow
+{
+    internal class CastTypeHandler<T> : IParameterTypeHandler
+    {
+        NpgsqlParameter IParameterTypeHandler.Handle(string name, object val)
+            => new NpgsqlParameter<T>(name, (T)val);
+    }
+}

src/Venflow/Venflow/Database.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Data;
@@ -351,12 +351,12 @@ internal void ExecuteLoggers(IReadOnlyList<LoggerCallback> loggers, NpgsqlComman
 
         private void Build()
         {
-            var type = this.GetType();
-
-            if (!DatabaseConfigurationCache.DatabaseConfigurations.TryGetValue(type, out var configuration))
+            if (!DatabaseConfigurationCache.DatabaseConfigurations.TryGetValue(this.GetType(), out var configuration))
             {
                 lock (DatabaseConfigurationCache.BuildLocker)
                 {
+                    var type = this.GetType();
+
                     if (!DatabaseConfigurationCache.DatabaseConfigurations.TryGetValue(type, out configuration))
                     {
                         var dbConfigurator = new DatabaseConfigurationFactory();

src/Venflow/Venflow/DatabaseConfigurationOptionsBuilder.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
+using System.Text;
+using Npgsql;
 using Venflow.Modeling.Definitions;
 
 namespace Venflow
@@ -59,5 +61,57 @@ public DatabaseConfigurationOptionsBuilder UseConfigurations(params Assembly[] a
 
             return this;
         }
+
+
+        /// <summary>
+        /// Maps a PostgreSQL enum to a CLR enum.
+        /// </summary>
+        /// <typeparam name="TEnum">The type of the enum.</typeparam>
+        /// <param name="name">The name of the enum in PostgreSQL, if none used it will try to convert the name of the CLR enum e.g. 'FooBar' to 'foo_bar'</param>
+        /// <param name="npgsqlNameTranslator">A component which will be used to translate CLR names (e.g. SomeClass) into database names (e.g. some_class). Defaults to <see cref="Npgsql.NameTranslation.NpgsqlSnakeCaseNameTranslator"/>.</param>
+        /// <returns>The same builder instance so that multiple calls can be chained.</returns>
+        public DatabaseConfigurationOptionsBuilder RegisterPostgresEnum<TEnum>(string? name = default, INpgsqlNameTranslator? npgsqlNameTranslator = default) where TEnum : struct, Enum
+        {
+            var type = typeof(TEnum);
+
+            if (string.IsNullOrWhiteSpace(name))
+            {
+                var underlyingType = Nullable.GetUnderlyingType(type);
+
+                name = underlyingType is not null ? underlyingType.Name : type.Name;
+
+                var nameBuilder = new StringBuilder(name.Length * 2 - 1);
+
+                nameBuilder.Append(char.ToLowerInvariant(name[0]));
+
+                var nameSpan = name.AsSpan();
+
+                for (int i = 1; i < nameSpan.Length; i++)
+                {
+                    var c = nameSpan[i];
+
+                    if (char.IsUpper(c))
+                    {
+                        nameBuilder.Append('_');
+                        nameBuilder.Append(char.ToLowerInvariant(c));
+                    }
+                    else
+                    {
+                        nameBuilder.Append(c);
+                    }
+                }
+
+                name = nameBuilder.ToString();
+            }
+
+            if (!ParameterTypeHandler.PostgreEnums.Contains(type))
+            {
+                NpgsqlConnection.GlobalTypeMapper.MapEnum<TEnum>(name, npgsqlNameTranslator);
+
+                ParameterTypeHandler.PostgreEnums.Add(type);
+            }
+
+            return this;
+        }
     }
-}
+}

src/Venflow/Venflow/Modeling/Definitions/Builder/EntityBuilder.cs

@@ -113,6 +113,7 @@ IEntityBuilder<TEntity> IEntityBuilder<TEntity>.MapId<TTarget>(Expression<Func<T
             return this;
         }
 
+        [Obsolete("This method will be removed in the next major version. Please instead use the DatabaseConfigurationOptionsBuilder.RegisterPostgresEnum method on the Database.Configure method.")]
         IEntityBuilder<TEntity> IEntityBuilder<TEntity>.MapPostgresEnum<TTarget>(Expression<Func<TEntity, TTarget?>> propertySelector, string? name, INpgsqlNameTranslator? npgsqlNameTranslator)
         {
             var property = propertySelector.ValidatePropertySelector();
@@ -122,6 +123,7 @@ IEntityBuilder<TEntity> IEntityBuilder<TEntity>.MapPostgresEnum<TTarget>(Express
             return this;
         }
 
+        [Obsolete("This method will be removed in the next major version. Please instead use the DatabaseConfigurationOptionsBuilder.RegisterPostgresEnum method on the Database.Configure method.")]
         IEntityBuilder<TEntity> IEntityBuilder<TEntity>.MapPostgresEnum<TTarget>(Expression<Func<TEntity, TTarget>> propertySelector, string? name, INpgsqlNameTranslator? npgsqlNameTranslator)
         {
             var property = propertySelector.ValidatePropertySelector();
@@ -164,11 +166,11 @@ private void MapPostgresEnum<TTarget>(PropertyInfo property, string? name, INpgs
                 name = nameBuilder.ToString();
             }
 
-            if (!PostgreSQLEnums.Contains(name))
+            if (!ParameterTypeHandler.PostgreEnums.Contains(property.PropertyType))
             {
                 NpgsqlConnection.GlobalTypeMapper.MapEnum<TTarget>(name, npgsqlNameTranslator);
 
-                PostgreSQLEnums.Add(name);
+                ParameterTypeHandler.PostgreEnums.Add(property.PropertyType);
             }
 
             ColumnDefinitions[property.Name].Options |= ColumnOptions.PostgreEnum;
@@ -443,13 +445,6 @@ internal abstract class EntityBuilder
     {
         internal static uint RelationCounter { get; set; }
 
-        internal static ConcurrentBag<string> PostgreSQLEnums { get; }
-
-        static EntityBuilder()
-        {
-            PostgreSQLEnums = new ConcurrentBag<string>();
-        }
-
         internal List<EntityRelationDefinition> Relations { get; }
         internal abstract Type Type { get; }
 
@@ -508,6 +503,7 @@ protected EntityBuilder()
         /// <param name="name">The name of the enum in PostgreSQL, if none used it will try to convert the name of the CLR enum e.g. 'FooBar' to 'foo_bar'</param>
         /// <param name="npgsqlNameTranslator">A component which will be used to translate CLR names (e.g. SomeClass) into database names (e.g. some_class). Defaults to <see cref="Npgsql.NameTranslation.NpgsqlSnakeCaseNameTranslator"/>.</param>
         /// <returns>The same builder instance so that multiple calls can be chained.</returns>
+        [Obsolete("This method will be removed in the next major version. Please instead use the DatabaseConfigurationOptionsBuilder.RegisterPostgresEnum method on the Database.Configure method.")]
         IEntityBuilder<TEntity> MapPostgresEnum<TTarget>(Expression<Func<TEntity, TTarget>> propertySelector, string? name = default, INpgsqlNameTranslator? npgsqlNameTranslator = default)
             where TTarget : struct, Enum;
 
@@ -519,6 +515,7 @@ IEntityBuilder<TEntity> MapPostgresEnum<TTarget>(Expression<Func<TEntity, TTarge
         /// <param name="name">The name of the enum in PostgreSQL, if none used it will try to convert the name of the CLR enum e.g. 'FooBar' to 'foo_bar'</param>
         /// <param name="npgsqlNameTranslator">A component which will be used to translate CLR names (e.g. SomeClass) into database names (e.g. some_class). Defaults to <see cref="Npgsql.NameTranslation.NpgsqlSnakeCaseNameTranslator"/>.</param>
         /// <returns>The same builder instance so that multiple calls can be chained.</returns>
+        [Obsolete("This method will be removed in the next major version. Please instead use the DatabaseConfigurationOptionsBuilder.RegisterPostgresEnum method on the Database.Configure method.")]
         IEntityBuilder<TEntity> MapPostgresEnum<TTarget>(Expression<Func<TEntity, TTarget?>> propertySelector, string? name = default, INpgsqlNameTranslator? npgsqlNameTranslator = default)
             where TTarget : struct, Enum;
     }

src/Venflow/Venflow/ParameterTypeHandler.cs

@@ -1,5 +1,5 @@
 using System;
-using System.Runtime.CompilerServices;
+using System.Collections.Generic;
 using Npgsql;
 
 namespace Venflow
@@ -9,13 +9,19 @@ namespace Venflow
     /// </summary>
     public static class ParameterTypeHandler
     {
-        private readonly static ConditionalWeakTable<Type, IParameterTypeHandler> _typeHandlers = new ConditionalWeakTable<Type, IParameterTypeHandler>();
+        internal static HashSet<Type> PostgreEnums => _postgreEnums;
+
+        private readonly static Dictionary<Type, IParameterTypeHandler> _typeHandlers = new Dictionary<Type, IParameterTypeHandler>();
+        private readonly static Dictionary<Type, IParameterTypeHandler> _castHandlers = new Dictionary<Type, IParameterTypeHandler>(1);
+        private readonly static HashSet<Type> _postgreEnums = new HashSet<Type>(0);
 
         static ParameterTypeHandler()
         {
             var uInt64Handler = new UInt64Handler();
             AddTypeHandler(typeof(ulong), uInt64Handler);
             AddTypeHandler(typeof(ulong?), uInt64Handler);
+
+            _castHandlers.Add(typeof(ulong), uInt64Handler);
         }
 
         /// <summary>
@@ -28,57 +34,136 @@ public static void AddTypeHandler(Type type, IParameterTypeHandler typeHandler)
 
         internal static NpgsqlParameter HandleParameter(string name, object? val)
         {
+            Type? type = null;
+            IParameterTypeHandler? handler;
+
             switch (val)
             {
                 case null:
                     return new NpgsqlParameter(name, DBNull.Value);
                 case IKey key:
                     val = key.BoxedValue;
                     break;
+                case Enum:
+                    type = val.GetType();
+
+                    var tempType = Nullable.GetUnderlyingType(type) ?? type;
+
+                    if (!_postgreEnums.Contains(tempType))
+                    {
+                        if (!_typeHandlers.TryGetValue(tempType, out handler))
+                        {
+                            var underlyingType = tempType.GetEnumUnderlyingType();
+
+                            if (!_castHandlers.TryGetValue(underlyingType, out handler))
+                            {
+                                handler = (IParameterTypeHandler)Activator.CreateInstance(typeof(CastTypeHandler<>).MakeGenericType(underlyingType));
+
+                                _castHandlers.Add(underlyingType, handler);
+                            }
+
+                            _typeHandlers.Add(tempType, handler);
+                        }
+
+                        return handler.Handle(name, val);
+                    }
+                    break;
             }
 
-            if (!_typeHandlers.TryGetValue(val.GetType(), out var handler))
+            type ??= val.GetType();
+
+            if (!_typeHandlers.TryGetValue(type, out handler))
                 return new NpgsqlParameter(name, val);
 
             return handler.Handle(name, val);
         }
 
         internal static NpgsqlParameter HandleParameter<T>(string name, T? val)
         {
+            Type? type = null;
             IParameterTypeHandler? handler;
 
             switch (val)
             {
                 case null:
                     return new NpgsqlParameter<DBNull>(name, DBNull.Value);
-
                 case IKey key:
                     var tempVal = key.BoxedValue;
 
                     if (!_typeHandlers.TryGetValue(tempVal.GetType(), out handler))
                         return new NpgsqlParameter(name, tempVal);
 
                     return handler.Handle(name, tempVal);
+                case Enum:
+                    type = val.GetType();
+
+                    var tempType = Nullable.GetUnderlyingType(type) ?? type;
+
+                    if (!_postgreEnums.Contains(tempType))
+                    {
+                        if (!_typeHandlers.TryGetValue(tempType, out handler))
+                        {
+                            var underlyingType = tempType.GetEnumUnderlyingType();
+
+                            if (!_castHandlers.TryGetValue(underlyingType, out handler))
+                            {
+                                handler = (IParameterTypeHandler)Activator.CreateInstance(typeof(CastTypeHandler<>).MakeGenericType(underlyingType));
+
+                                _castHandlers.Add(underlyingType, handler);
+                            }
+
+                            _typeHandlers.Add(tempType, handler);
+                        }
+
+                        return handler.Handle(name, val);
+                    }
+                    break;
             }
 
-            if (!_typeHandlers.TryGetValue(val.GetType(), out handler))
+            type ??= val.GetType();
+
+            if (!_typeHandlers.TryGetValue(type, out handler))
                 return new NpgsqlParameter<T>(name, val);
 
             return handler.Handle(name, val);
         }
 
         internal static NpgsqlParameter HandleParameter(string name, Type type, object? val)
         {
+            IParameterTypeHandler? handler;
+
             switch (val)
             {
                 case null:
                     return new NpgsqlParameter(name, DBNull.Value);
                 case IKey key:
                     val = key.BoxedValue;
                     break;
+                case Enum:
+                    var tempType = Nullable.GetUnderlyingType(type) ?? type;
+
+                    if (!_postgreEnums.Contains(tempType))
+                    {
+                        if (!_typeHandlers.TryGetValue(tempType, out handler))
+                        {
+                            var underlyingType = tempType.GetEnumUnderlyingType();
+
+                            if (!_castHandlers.TryGetValue(underlyingType, out handler))
+                            {
+                                handler = (IParameterTypeHandler)Activator.CreateInstance(typeof(CastTypeHandler<>).MakeGenericType(underlyingType));
+
+                                _castHandlers.Add(underlyingType, handler);
+                            }
+
+                            _typeHandlers.Add(tempType, handler);
+                        }
+
+                        return handler.Handle(name, val);
+                    }
+                    break;
             }
 
-            if (!_typeHandlers.TryGetValue(type, out var handler))
+            if (!_typeHandlers.TryGetValue(type, out handler))
                 return new NpgsqlParameter(name, val);
 
             return handler.Handle(name, val);