v9.2.2

Author: Samuel Abraham

src/TypeCache.GraphQL/Extensions/GraphQLExtensions.cs

@@ -37,7 +37,7 @@ public static FieldType AddField(this IComplexGraphType @this, MethodEntity meth
 
 	public static FieldType AddField(this IComplexGraphType @this, MethodEntity method, IFieldResolver resolver)
 	{
-		var fieldType = CreateFieldType(method);
+		var fieldType = CreateFieldType(method, method.Return.ParameterType);
 		fieldType.Resolver = resolver;
 		return fieldType;
 	}
@@ -47,7 +47,7 @@ public static FieldType AddField(this IComplexGraphType @this, StaticMethodEntit
 
 	public static FieldType AddField(this IComplexGraphType @this, StaticMethodEntity method, IFieldResolver resolver)
 	{
-		var fieldType = CreateFieldType(method);
+		var fieldType = CreateFieldType(method, method.Return.ParameterType);
 		fieldType.Resolver = resolver;
 		return fieldType;
 	}
@@ -57,7 +57,7 @@ public static FieldType AddFieldStream(this IComplexGraphType @this, MethodEntit
 
 	public static FieldType AddFieldStream(this IComplexGraphType @this, MethodEntity method, ISourceStreamResolver resolver)
 	{
-		var fieldType = CreateFieldType(method);
+		var fieldType = CreateFieldType(method, method.Return.ParameterType);
 		fieldType.StreamResolver = resolver;
 		return fieldType;
 	}
@@ -67,7 +67,7 @@ public static FieldType AddFieldStream(this IComplexGraphType @this, StaticMetho
 
 	public static FieldType AddFieldStream(this IComplexGraphType @this, StaticMethodEntity method, ISourceStreamResolver resolver)
 	{
-		var fieldType = CreateFieldType(method);
+		var fieldType = CreateFieldType(method, method.Return.ParameterType);
 		fieldType.StreamResolver = resolver;
 		return fieldType;
 	}
@@ -213,7 +213,7 @@ public static Type ToListGraphType(this Type @this)
 	public static Type ToNonNullGraphType(this Type @this)
 		=> typeof(NonNullGraphType<>).MakeGenericType(@this);
 
-	private static FieldType CreateFieldType(Method method)
+	private static FieldType CreateFieldType(Method method, Type returnType)
 		=> new()
 		{
 			Arguments = new QueryArguments(method.Parameters
@@ -226,6 +226,6 @@ private static FieldType CreateFieldType(Method method)
 			Name = (method.Attributes.GraphQLName() ?? method.Name).TrimEndIgnoreCase("Async"),
 			Description = method.Attributes.GraphQLDescription(),
 			DeprecationReason = method.Attributes.GraphQLDeprecationReason(),
-			Type = method.Return.ParameterType.ToGraphQLType(false).ToNonNullGraphType()
+			Type = returnType.ToGraphQLType(false).ToNonNullGraphType()
 		};
 }

src/TypeCache.GraphQL/Extensions/SchemaExtensions.cs

@@ -1042,7 +1042,7 @@ public static FieldType AddSqlApiInsertEndpoint<T>(this ISchema @this, IDataSour
 		{
 			Name = Invariant($"{Type<T>.Attributes.GraphQLName() ?? Type<T>.Name}OrderBy"),
 		};
-		foreach (var property in Type<T>.Properties.Values.Where(_ => !_.IsStaticGet && !_.IsStaticSet && !_.Attributes.GraphQLIgnore()))
+		foreach (var property in Type<T>.Properties.Values.Where(_ => !_.Attributes.GraphQLIgnore()))
 		{
 			var propertyName = property.Attributes.GraphQLName() ?? property.Name;
 			var propertyDeprecationReason = property.Attributes.GraphQLDeprecationReason();

src/TypeCache.GraphQL/Extensions/ServiceCollectionExtensions.cs

@@ -11,6 +11,7 @@
 using TypeCache.GraphQL.Listeners;
 using TypeCache.GraphQL.Types;
 using TypeCache.GraphQL.Web;
+using TypeCache.Reflection;
 
 namespace TypeCache.GraphQL.Extensions;
 
@@ -70,10 +71,10 @@ public static IServiceCollection AddGraphQL(this IServiceCollection @this)
 	/// <param name="options">
 	/// Place to make calls to:<br/>
 	/// <c>
-	/// <see cref="OutputGraphType{T}.AddField(PropertyInfo)"/><br/>
-	/// <see cref="OutputGraphType{T}.AddField(MethodInfo)"/><br/>
-	/// <see cref="OutputGraphType{T}.AddField{ITEM}(MethodInfo, Func{T, ITEM[], ITEM})"/>
-	/// <see cref="OutputGraphType{T}.AddField{ITEM}(MethodInfo, Func{T, ITEM[], ITEM[]})"/>
+	/// <see cref="OutputGraphType{T}.AddField(PropertyEntity)"/><br/>
+	/// <see cref="OutputGraphType{T}.AddField(StaticMethodEntity)"/><br/>
+	/// <see cref="OutputGraphType{T}.AddField{ITEM}(StaticMethodEntity, Func{T, ITEM[], ITEM})"/>
+	/// <see cref="OutputGraphType{T}.AddField{ITEM}(StaticMethodEntity, Func{T, ITEM[], ITEM[]})"/>
 	/// </c>
 	/// </param>
 	public static IServiceCollection AddGraphQLTypeExtensions<T>(this IServiceCollection @this, Action<OutputGraphType<T>> options)

src/TypeCache.GraphQL/TypeCache.GraphQL.csproj

@@ -4,7 +4,7 @@
     <Nullable>enable</Nullable>
     <RootNamespace>TypeCache.GraphQL</RootNamespace>
     <PackageId>TypeCache.GraphQL</PackageId>
-    <Version>9.2.1</Version>
+    <Version>9.2.2</Version>
 	<Authors>Samuel Abraham &lt;sam987883@gmail.com&gt;</Authors>
     <Company>Samuel Abraham &lt;sam987883@gmail.com&gt;</Company>
     <Title>TypeCache GraphQL</Title>

src/TypeCache.GraphQL/Types/InputGraphType.cs

@@ -17,7 +17,7 @@ public InputGraphType()
 		this.DeprecationReason = Type<T>.Attributes.GraphQLDeprecationReason();
 
 		Type<T>.Properties.Values
-			.Where(_ => !_.IsStaticGet && !_.IsStaticSet && _.CanRead && _.CanWrite && !_.Attributes.GraphQLIgnore())
+			.Where(_ => _.CanRead && _.CanWrite && !_.Attributes.GraphQLIgnore())
 			.ForEach(_ => this.AddField(new()
 			{
 				Type = _.ToGraphQLType(true),

src/TypeCache.GraphQL/Types/OutputGraphType.cs

@@ -72,7 +72,7 @@ public FieldType AddField<ITEM>(StaticMethodEntity method)
 	/// The name of the field is the name or <see cref="GraphQLNameAttribute"/> of the <paramref name="method"/>.
 	/// </summary>
 	/// <param name="method">The method that loads data for all result items (<typeparamref name="ITEM"/>[]).  This method can contain user input query parameters.</param>
-	/// <param name="getResult">Reduces the data returned by <paramref name="methodInfo"/>.</param>
+	/// <param name="getResult">Reduces the data returned by <paramref name="method"/>.</param>
 	public FieldType AddField<ITEM>(StaticMethodEntity method, Func<T, ITEM[], ITEM> getResult)
 		where ITEM : notnull
 	{
@@ -103,7 +103,7 @@ public FieldType AddField<ITEM>(StaticMethodEntity method, Func<T, ITEM[], ITEM>
 	/// The name of the field is the name or <see cref="GraphQLNameAttribute"/> of the <paramref name="method"/>.
 	/// </summary>
 	/// <param name="method">The method that loads data for all result items.  This method can contain user input query parameters.</param>
-	/// <param name="getResult">Reduces the data returned by <paramref name="methodInfo"/>.</param>
+	/// <param name="getResult">Reduces the data returned by <paramref name="method"/>.</param>
 	public FieldType AddField<ITEM>(StaticMethodEntity method, Func<T, ITEM[], ITEM[]> getResult)
 		where ITEM : notnull
 	{

src/TypeCache/Adapters/CollectionAdapter.cs

@@ -6,58 +6,58 @@
 
 namespace TypeCache.Adapters;
 
-internal sealed class CollectionAdapter : ICollection<object>
+public class CollectionAdapter : ICollection<object>
 {
-	private readonly object _Collection;
+	protected readonly object _Collection;
 
 	private readonly PropertyEntity _Count;
 	private readonly PropertyEntity _IsReadOnly;
-	private readonly MethodSet<MethodEntity> _Add;
-	private readonly MethodSet<MethodEntity> _Clear;
-	private readonly MethodSet<MethodEntity> _Contains;
-	private readonly MethodSet<MethodEntity> _CopyTo;
-	private readonly MethodSet<MethodEntity> _GetEnumerator;
-	private readonly MethodSet<MethodEntity> _Remove;
+	private readonly MethodEntity _Add;
+	private readonly MethodEntity _Clear;
+	private readonly MethodEntity _Contains;
+	private readonly MethodEntity _CopyTo;
+	private readonly MethodEntity _Remove;
 
 	public CollectionAdapter(object collection)
 	{
+		collection.ThrowIfNull();
+		(collection.GetType().Implements(typeof(ICollection<>))).ThrowIfFalse();
+
 		this._Collection = collection;
 
-		var methods = collection.GetType().Methods();
-		var properties = collection.GetType().Properties();
-
-		this._Count = properties[nameof(Count)];
-		this._IsReadOnly = properties[nameof(IsReadOnly)];
-		this._Add = methods[nameof(Add)];
-		this._Clear = methods[nameof(Clear)];
-		this._Contains = methods[nameof(Contains)];
-		this._CopyTo = methods[nameof(CopyTo)];
-		this._GetEnumerator = methods[nameof(GetEnumerator)];
-		this._Remove = methods[nameof(Remove)];
+		var collectionType = collection.GetType().GetInterfaces().First(_ => _.Is(typeof(ICollection<>)));
+
+		this._Count = collectionType.Properties()[nameof(Count)];
+		this._IsReadOnly = collectionType.Properties()[nameof(IsReadOnly)];
+		this._Add = collectionType.Methods()[nameof(Add)].First();
+		this._Clear = collectionType.Methods()[nameof(Clear)].First()!;
+		this._Contains = collectionType.Methods()[nameof(Contains)].First();
+		this._CopyTo = collectionType.Methods()[nameof(CopyTo)].First();
+		this._Remove = collectionType.Methods()[nameof(Remove)].First();
 	}
 
 	public int Count => (int)this._Count.GetValue(this._Collection)!;
 
 	public bool IsReadOnly => (bool)this._IsReadOnly.GetValue(this._Collection)!;
 
 	public void Add(object item)
-		=> this._Add.Find([item])!.Invoke(this._Collection, item.ToValueTuple());
+		=> this._Add.Invoke(this._Collection, item.ToValueTuple());
 
 	public void Clear()
-		=> this._Clear.FindWithNoArguments()!.Invoke(this._Collection);
+		=> this._Clear.Invoke(this._Collection);
 
 	public bool Contains(object item)
-		=> (bool)this._Contains.Find([item])!.Invoke(this._Collection, item.ToValueTuple())!;
+		=> (bool)this._Contains.Invoke(this._Collection, item.ToValueTuple())!;
 
 	public void CopyTo(object[] array, int arrayIndex)
-		=> this._CopyTo.Find([array, arrayIndex])!.Invoke(this._Collection, [array, arrayIndex]);
+		=> this.ForEach(item => array[arrayIndex++] = item);
 
-	public IEnumerator<object> GetEnumerator()
-		=> (IEnumerator<object>)this._GetEnumerator.FindWithNoArguments()!.Invoke(this._Collection)!;
+	public IEnumerator GetEnumerator()
+		=> ((IEnumerable)this._Collection).GetEnumerator();
 
-	public bool Remove(object item)
-		=> (bool)this._Remove.Find([item])!.Invoke(this._Collection, item.ToValueTuple())!;
+	IEnumerator<object> IEnumerable<object>.GetEnumerator()
+		=> ((IEnumerable)this._Collection).OfType<object>().GetEnumerator();
 
-	IEnumerator IEnumerable.GetEnumerator()
-		=> this.GetEnumerator();
+	public bool Remove(object item)
+		=> (bool)this._Remove.Invoke(this._Collection, item.ToValueTuple())!;
 }

src/TypeCache/Adapters/DictionaryAdapter.cs

@@ -1,91 +1,73 @@
 // Copyright (c) 2021 Samuel Abraham
 
 using System.Collections;
+using System.Collections.Generic;
 using TypeCache.Extensions;
 using TypeCache.Reflection;
 
 namespace TypeCache.Adapters;
 
-internal class DictionaryAdapter : IDictionary<object, object>
+public class DictionaryAdapter : CollectionAdapter, IDictionary<object, object>
 {
 	private readonly object _Dictionary;
 
-	private readonly PropertyEntity _Count;
-	private readonly PropertyEntity _Item;
-	private readonly PropertyEntity _IsReadOnly;
+	private readonly PropertyIndexerEntity _Item;
 	private readonly PropertyEntity _Keys;
 	private readonly PropertyEntity _Values;
-	private readonly MethodSet<MethodEntity> _Add;
-	private readonly MethodSet<MethodEntity> _Clear;
-	private readonly MethodSet<MethodEntity> _ContainsKey;
-	private readonly MethodSet<MethodEntity> _CopyTo;
-	private readonly MethodSet<MethodEntity> _GetEnumerator;
-	private readonly MethodSet<MethodEntity> _Remove;
+	private readonly MethodEntity _Add;
+	private readonly MethodEntity _ContainsKey;
+	private readonly MethodEntity _Remove;
 
 	public DictionaryAdapter(object dictionary)
+		: base(dictionary)
 	{
 		this._Dictionary = dictionary;
+		(dictionary.GetType().Implements(typeof(IDictionary<,>))).ThrowIfFalse();
 
-		var methods = dictionary.GetType().Methods();
-		var properties = dictionary.GetType().Properties();
-
-		this._Count = properties[nameof(Count)];
-		this._Item = properties["Item"];
-		this._IsReadOnly = properties[nameof(IsReadOnly)];
-		this._Keys = properties[nameof(Keys)];
-		this._Values = properties[nameof(Values)];
-		this._Add = methods[nameof(Add)];
-		this._Clear = methods[nameof(Clear)];
-		this._ContainsKey = methods[nameof(ContainsKey)];
-		this._CopyTo = methods[nameof(CopyTo)];
-		this._GetEnumerator = methods[nameof(GetEnumerator)];
-		this._Remove = methods[nameof(Remove)];
+		var dictionaryType = dictionary.GetType().GetInterfaces().First(_ => _.Is(typeof(IDictionary<,>)));
+
+		this._Item = dictionaryType.DefaultIndexer()!;
+		this._Keys = dictionaryType.Properties()[nameof(Keys)];
+		this._Values = dictionaryType.Properties()[nameof(Values)];
+		this._Add = dictionaryType.Methods()[nameof(Add)].First(_ => _.Parameters.Count is 2);
+		this._ContainsKey = dictionaryType.Methods()[nameof(ContainsKey)].First();
+		this._Remove = dictionaryType.Methods()[nameof(Remove)].First(_ => _.Parameters[0].ParameterType == dictionaryType.GetGenericArguments()[0]);
 	}
 
 	public object this[object key]
 	{
-		get => this._Item[ValueTuple.Create(key)].GetValue(this._Dictionary)!;
-		set => this._Item[ValueTuple.Create(key)].SetValue(this._Dictionary, value);
+		get => this._Item.GetValue(this._Dictionary, ValueTuple.Create(key))!;
+		set => this._Item.SetValue(this._Dictionary, ValueTuple.Create(key), value);
 	}
 
 	public ICollection<object> Keys => new CollectionAdapter(this._Keys.GetValue(this._Dictionary)!);
 
 	public ICollection<object> Values => new CollectionAdapter(this._Values.GetValue(this._Dictionary)!);
 
-	public int Count => (int)_Count.GetValue(this._Dictionary)!;
-
-	public bool IsReadOnly => (bool)_IsReadOnly.GetValue(this._Dictionary)!;
-
 	public void Add(object key, object value)
-		=> _ = this._Add.Find([key, value])!.Invoke(this._Dictionary, [key, value]);
+		=> _ = this._Add.Invoke(this._Dictionary, [key, value]);
 
 	public void Add(KeyValuePair<object, object> item)
 		=> throw new NotImplementedException();
 
-	public void Clear()
-		=> _ = this._Clear.FindWithNoArguments()!.Invoke(this._Dictionary);
-
 	public bool Contains(KeyValuePair<object, object> item)
 		=> throw new NotImplementedException();
 
 	public bool ContainsKey(object key)
-		=> (bool)this._ContainsKey.Find(key.ToValueTuple())!.Invoke(this._Dictionary, [key])!;
+		=> (bool)this._ContainsKey.Invoke(this._Dictionary, [key])!;
 
 	public void CopyTo(KeyValuePair<object, object>[] array, int arrayIndex)
 		=> throw new NotImplementedException();
 
-	public IEnumerator<KeyValuePair<object, object>> GetEnumerator()
+	IEnumerator<KeyValuePair<object, object>> IEnumerable<KeyValuePair<object, object>>.GetEnumerator()
 		=> throw new NotImplementedException();
 
 	public bool Remove(object key)
-		=> (bool)this._Remove.Find(key.ToValueTuple())!.Invoke(this._Dictionary, [key])!;
+		=> (bool)this._Remove.Invoke(this._Dictionary, [key])!;
 
 	public bool Remove(KeyValuePair<object, object> item)
 		=> throw new NotImplementedException();
 
 	public bool TryGetValue(object key, [MaybeNullWhen(false)] out object value)
 		=> throw new NotImplementedException();
-
-	IEnumerator IEnumerable.GetEnumerator()
-		=> (IEnumerator)this._GetEnumerator.FindWithNoArguments()!.Invoke(this._Dictionary)!;
 }