Better error message when there's more than 1 resolver

Author: rasmusjp

src/Our.Umbraco.GraphQL/Types/ComplexGraphTypeOfIPublishedContentExtensions.cs

@@ -1,6 +1,8 @@
 using GraphQL;
 using GraphQL.Types;
 using Our.Umbraco.GraphQL.ValueResolvers;
+using System;
+using System.Linq;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.PublishedContent;
 
@@ -27,8 +29,7 @@ public static ComplexGraphType<IPublishedContent> AddUmbracoContentPropeties(
 
                 var publishedPropertyType = publishedContentType.GetPropertyType(property.Alias);
 
-                var resolver = GraphQLValueResolversResolver.Current.FindResolver(publishedPropertyType)
-                               ?? new DefaultValueResolver();
+                var resolver = GetValueResolver(contentType, publishedPropertyType);
 
                 var propertyGraphType = resolver.GetGraphQLType(publishedPropertyType);
 
@@ -53,5 +54,36 @@ public static ComplexGraphType<IPublishedContent> AddUmbracoContentPropeties(
 
             return graphType;
         }
+
+        private static IGraphQLValueResolver GetValueResolver(IContentTypeComposition contentType, PublishedPropertyType propertyType)
+        {
+            var foundResolvers = GraphQLValueResolversResolver.Current.Resolvers.Where(r => r.IsResolver(propertyType)).ToList();
+            var defaultResolvers = GraphQLValueResolversResolver.Current.DefaultResolvers;
+
+            if(foundResolvers.Count == 1)
+            {
+                return foundResolvers[0];
+            }
+
+            if (foundResolvers.Count > 0)
+            {
+                //more than one resolver was found
+                //get the non-default and see if we have only one
+                var nonDefault = foundResolvers.Except(defaultResolvers.Select(x => x.Item1)).ToList();
+                if (nonDefault.Count == 1)
+                {
+                    //there's only 1 custom resolver registered, so use it
+                    return nonDefault[0];
+                }
+
+                //this is not allowed, there cannot be more than 1 resolver
+                throw new InvalidOperationException($"Type '{nonDefault[1].GetType().FullName}' cannot be an IGraphQLValueResolver" +
+                    $" for property '{propertyType.PropertyTypeAlias}' of content type '{contentType.Alias}' because type '{nonDefault[0].GetType().FullName}' has already been detected as a resolver" +
+                    $" for that property, and only one converter can exist for a resolver.");
+            }
+
+            //no resolvers registered so we use the fallback resolver
+            return GraphQLValueResolversResolver.Current.FallbackResolver;
+        }
     }
 }

src/Our.Umbraco.GraphQL/ValueResolvers/BooleanValueResolver.cs

@@ -5,6 +5,7 @@
 
 namespace Our.Umbraco.GraphQL.ValueResolvers
 {
+    [DefaultGraphQLValueResolver]
     public class BooleanValueResolver : GraphQLValueResolver
     {
         public override Type GetGraphQLType(PublishedPropertyType propertyType)
@@ -14,7 +15,7 @@ public override Type GetGraphQLType(PublishedPropertyType propertyType)
                 : typeof(ListGraphType<BooleanGraphType>);
         }
 
-        public override bool IsConverter(PublishedPropertyType propertyType)
+        public override bool IsResolver(PublishedPropertyType propertyType)
         {
             return propertyType.ClrType == typeof(bool) ||
                    propertyType.ClrType == typeof(IEnumerable<bool>);

src/Our.Umbraco.GraphQL/ValueResolvers/DateValueResolver.cs

@@ -5,6 +5,7 @@
 
 namespace Our.Umbraco.GraphQL.ValueResolvers
 {
+    [DefaultGraphQLValueResolver]
     public class DateValueResolver : GraphQLValueResolver
     {
         public override Type GetGraphQLType(PublishedPropertyType propertyType)
@@ -15,7 +16,7 @@ public override Type GetGraphQLType(PublishedPropertyType propertyType)
                 : typeof(ListGraphType<DateGraphType>);
         }
 
-        public override bool IsConverter(PublishedPropertyType propertyType)
+        public override bool IsResolver(PublishedPropertyType propertyType)
         {
             return propertyType.ClrType == typeof(DateTime) ||
                    propertyType.ClrType == typeof(DateTimeOffset) ||

src/Our.Umbraco.GraphQL/ValueResolvers/DecimalValueResolver.cs

@@ -5,6 +5,7 @@
 
 namespace Our.Umbraco.GraphQL.ValueResolvers
 {
+    [DefaultGraphQLValueResolver]
     public class DecimalValueResolver : GraphQLValueResolver
     {
         public override Type GetGraphQLType(PublishedPropertyType propertyType)
@@ -15,7 +16,7 @@ public override Type GetGraphQLType(PublishedPropertyType propertyType)
                 : typeof(ListGraphType<DecimalGraphType>);
         }
 
-        public override bool IsConverter(PublishedPropertyType propertyType)
+        public override bool IsResolver(PublishedPropertyType propertyType)
         {
             return propertyType.ClrType == typeof(decimal) ||
                    propertyType.ClrType == typeof(double) ||

src/Our.Umbraco.GraphQL/ValueResolvers/DefaultGraphQLValueResolverAttribute.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Our.Umbraco.GraphQL.ValueResolvers
+{
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
+    internal sealed class DefaultGraphQLValueResolverAttribute : Attribute
+    {
+    }
+}

src/Our.Umbraco.GraphQL/ValueResolvers/DefaultValueResolver.cs

@@ -16,7 +16,7 @@ public override Type GetGraphQLType(PublishedPropertyType propertyType)
             return typeof(StringGraphType);
         }
 
-        public override bool IsConverter(PublishedPropertyType propertyType)
+        public override bool IsResolver(PublishedPropertyType propertyType)
         {
             return false;
         }

src/Our.Umbraco.GraphQL/ValueResolvers/FloatValueResolver.cs

@@ -5,6 +5,7 @@
 
 namespace Our.Umbraco.GraphQL.ValueResolvers
 {
+    [DefaultGraphQLValueResolver]
     public class FloatValueResolver : GraphQLValueResolver
     {
         public override Type GetGraphQLType(PublishedPropertyType propertyType)
@@ -14,7 +15,7 @@ public override Type GetGraphQLType(PublishedPropertyType propertyType)
                 : typeof(ListGraphType<FloatGraphType>);
         }
 
-        public override bool IsConverter(PublishedPropertyType propertyType)
+        public override bool IsResolver(PublishedPropertyType propertyType)
         {
             return propertyType.ClrType == typeof(float) ||
                    propertyType.ClrType == typeof(IEnumerable<float>);

src/Our.Umbraco.GraphQL/ValueResolvers/GraphQLValueResolver.cs

@@ -1,8 +1,9 @@
-using System;
+using System;
 using Umbraco.Core.Models.PublishedContent;
 
 namespace Our.Umbraco.GraphQL.ValueResolvers
 {
+    [DefaultGraphQLValueResolver]
     public abstract class GraphQLValueResolver : IGraphQLValueResolver
     {
         public abstract Type GetGraphQLType(PublishedPropertyType propertyType);
@@ -12,6 +13,6 @@ public virtual object Resolve(PublishedPropertyType propertyType, object value)
             return value;
         }
 
-        public abstract bool IsConverter(PublishedPropertyType propertyType);
+        public abstract bool IsResolver(PublishedPropertyType propertyType);
     }
-}
+}

src/Our.Umbraco.GraphQL/ValueResolvers/GraphQLValueResolversResolver.cs

@@ -1,26 +1,80 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
+using System.Threading;
+using Umbraco.Core;
 using Umbraco.Core.Logging;
-using Umbraco.Core.Models.PublishedContent;
 using Umbraco.Core.ObjectResolution;
 
 namespace Our.Umbraco.GraphQL.ValueResolvers
 {
     public class GraphQLValueResolversResolver : ManyObjectsResolverBase<GraphQLValueResolversResolver, IGraphQLValueResolver>
     {
+        private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
+        private Tuple<IGraphQLValueResolver, DefaultGraphQLValueResolverAttribute>[] _defaults = null;
+        private IGraphQLValueResolver _fallback = null;
+
         internal GraphQLValueResolversResolver(IServiceProvider serviceProvider, ILogger logger,
             IEnumerable<Type> value, ObjectLifetimeScope scope = ObjectLifetimeScope.Application) : base(
             serviceProvider, logger, value, scope)
         {
         }
 
-        public IEnumerable<IGraphQLValueResolver> Converters => Values;
+        public IEnumerable<IGraphQLValueResolver> Resolvers => Values;
 
-        internal IGraphQLValueResolver FindResolver(PublishedPropertyType propertyType)
+        /// <summary>
+        /// Caches and gets the default resolvers with their metadata
+        /// </summary>
+        internal Tuple<IGraphQLValueResolver, DefaultGraphQLValueResolverAttribute>[] DefaultResolvers
         {
-            // TODO: Validate multiple found and throw better exceptions
-            return Values.SingleOrDefault(x => x.IsConverter(propertyType));
+            get
+            {
+                using (var locker = new UpgradeableReadLock(_lock))
+                {
+                    if (_defaults == null)
+                    {
+                        locker.UpgradeToWriteLock();
+
+                        var defaultResolverWithAttributes = Resolvers
+                            .Select(x => new
+                            {
+                                attribute = x.GetType().GetCustomAttribute<DefaultGraphQLValueResolverAttribute>(false),
+                                resolver = x
+                            })
+                            .Where(x => x.attribute != null)
+                            .ToArray();
+
+                        _defaults = defaultResolverWithAttributes
+                            .Select(
+                                x => new Tuple<IGraphQLValueResolver, DefaultGraphQLValueResolverAttribute>(x.resolver, x.attribute))
+                            .ToArray();
+                    }
+
+                    return _defaults;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Caches and gets the fallback resolver
+        /// </summary>
+        internal IGraphQLValueResolver FallbackResolver
+        {
+            get
+            {
+                using (var locker = new UpgradeableReadLock(_lock))
+                {
+                    if (_fallback == null)
+                    {
+                        locker.UpgradeToWriteLock();
+
+                        _fallback = Resolvers.Single(x => x is DefaultValueResolver);
+                    }
+
+                    return _fallback;
+                }
+            }
         }
     }
 }

src/Our.Umbraco.GraphQL/ValueResolvers/GridValueResolver.cs

@@ -4,14 +4,15 @@
 
 namespace Our.Umbraco.GraphQL.ValueResolvers
 {
+    [DefaultGraphQLValueResolver]
     public class GridValueResolver : GraphQLValueResolver
     {
         public override Type GetGraphQLType(PublishedPropertyType propertyType)
         {
             return typeof(GridGraphType);
         }
 
-        public override bool IsConverter(PublishedPropertyType propertyType)
+        public override bool IsResolver(PublishedPropertyType propertyType)
         {
             return propertyType.PropertyEditorAlias == global::Umbraco.Core.Constants.PropertyEditors.GridAlias;
         }