add ClaimsPrincipal User to filters

SimonCropp · web-flow · commit fe5c710ff674 · 2022-08-23T13:21:17.000+10:00
diff --git a/src/Directory.Build.props b/src/Directory.Build.props
@@ -2,7 +2,7 @@
 <Project>
   <PropertyGroup>
     <NoWarn>CS1591;NU5104;CS1573</NoWarn>
-    <Version>18.1.0</Version>
+    <Version>19.0.0</Version>
     <AssemblyVersion>1.0.0</AssemblyVersion>
     <PackageTags>EntityFrameworkCore, EntityFramework, GraphQL</PackageTags>
     <SignAssembly>false</SignAssembly>
diff --git a/src/GraphQL.EntityFramework/ConnectionConverter.cs b/src/GraphQL.EntityFramework/ConnectionConverter.cs
@@ -172,7 +172,7 @@ static async Task<Connection<TItem>> Range<TSource, TItem>(
         var page = list.Skip(skip).Take(take);
         QueryLogger.Write(page);
         IEnumerable<TItem> result = await page.ToListAsync(cancellation);
-        result = await filters.ApplyFilter(result, context.UserContext);
+        result = await filters.ApplyFilter(result, context.UserContext, context.User);
 
         cancellation.ThrowIfCancellationRequested();
         return Build(skip, take, count, result);
diff --git a/src/GraphQL.EntityFramework/Filters/Filters.cs b/src/GraphQL.EntityFramework/Filters/Filters.cs
@@ -1,25 +1,27 @@
-﻿namespace GraphQL.EntityFramework;
+﻿using System.Security.Claims;
+
+namespace GraphQL.EntityFramework;
 
 #region FiltersSignature
 
 public class Filters
 {
-    public delegate bool Filter<in TEntity>(object userContext, TEntity input)
+    public delegate bool Filter<in TEntity>(object userContext, ClaimsPrincipal? userPrincipal, TEntity input)
         where TEntity : class;
 
-    public delegate Task<bool> AsyncFilter<in TEntity>(object userContext, TEntity input)
+    public delegate Task<bool> AsyncFilter<in TEntity>(object userContext, ClaimsPrincipal? userPrincipal, TEntity input)
         where TEntity : class;
 
     #endregion
 
     public void Add<TEntity>(Filter<TEntity> filter)
         where TEntity : class =>
         funcs[typeof(TEntity)] =
-            (context, item) =>
+            (userContext, userPrincipal, item) =>
             {
                 try
                 {
-                    return Task.FromResult(filter(context, (TEntity) item));
+                    return Task.FromResult(filter(userContext, userPrincipal, (TEntity) item));
                 }
                 catch (Exception exception)
                 {
@@ -30,23 +32,23 @@ public void Add<TEntity>(Filter<TEntity> filter)
     public void Add<TEntity>(AsyncFilter<TEntity> filter)
         where TEntity : class =>
         funcs[typeof(TEntity)] =
-            async (context, item) =>
+            async (userContext, userPrincipal, item) =>
             {
                 try
                 {
-                    return await filter(context, (TEntity) item);
+                    return await filter(userContext, userPrincipal, (TEntity) item);
                 }
                 catch (Exception exception)
                 {
                     throw new($"Failed to execute filter. {nameof(TEntity)}: {typeof(TEntity)}.", exception);
                 }
             };
 
-    delegate Task<bool> Filter(object userContext, object input);
+    delegate Task<bool> Filter(object userContext, ClaimsPrincipal? userPrincipal, object input);
 
     Dictionary<Type, Filter> funcs = new();
 
-    internal virtual async Task<IEnumerable<TEntity>> ApplyFilter<TEntity>(IEnumerable<TEntity> result, object userContext)
+    internal virtual async Task<IEnumerable<TEntity>> ApplyFilter<TEntity>(IEnumerable<TEntity> result, object userContext, ClaimsPrincipal? userPrincipal)
         where TEntity : class
     {
         if (funcs.Count == 0)
@@ -63,7 +65,7 @@ internal virtual async Task<IEnumerable<TEntity>> ApplyFilter<TEntity>(IEnumerab
         var list = new List<TEntity>();
         foreach (var item in result)
         {
-            if (await ShouldInclude(userContext, item, filters))
+            if (await ShouldInclude(userContext, userPrincipal, item, filters))
             {
                 list.Add(item);
             }
@@ -72,12 +74,12 @@ internal virtual async Task<IEnumerable<TEntity>> ApplyFilter<TEntity>(IEnumerab
         return list;
     }
 
-    static async Task<bool> ShouldInclude<TEntity>(object userContext, TEntity item, List<AsyncFilter<TEntity>> filters)
+    static async Task<bool> ShouldInclude<TEntity>(object userContext, ClaimsPrincipal? userPrincipal, TEntity item, List<AsyncFilter<TEntity>> filters)
         where TEntity : class
     {
         foreach (var func in filters)
         {
-            if (!await func(userContext, item))
+            if (!await func(userContext, userPrincipal, item))
             {
                 return false;
             }
@@ -86,7 +88,7 @@ static async Task<bool> ShouldInclude<TEntity>(object userContext, TEntity item,
         return true;
     }
 
-    internal virtual async Task<bool> ShouldInclude<TEntity>(object userContext, TEntity? item)
+    internal virtual async Task<bool> ShouldInclude<TEntity>(object userContext, ClaimsPrincipal? userPrincipal, TEntity? item)
         where TEntity : class
     {
         if (item is null)
@@ -101,7 +103,7 @@ internal virtual async Task<bool> ShouldInclude<TEntity>(object userContext, TEn
 
         foreach (var func in FindFilters<TEntity>())
         {
-            if (!await func(userContext, item))
+            if (!await func(userContext, userPrincipal, item))
             {
                 return false;
             }
@@ -116,7 +118,7 @@ IEnumerable<AsyncFilter<TEntity>> FindFilters<TEntity>()
         var type = typeof(TEntity);
         foreach (var pair in funcs.Where(x => x.Key.IsAssignableFrom(type)))
         {
-            yield return (context, item) => pair.Value(context, item);
+            yield return (userContext, userPrincipal, item) => pair.Value(userContext, userPrincipal, item);
         }
     }
 }
diff --git a/src/GraphQL.EntityFramework/Filters/NullFilters.cs b/src/GraphQL.EntityFramework/Filters/NullFilters.cs
@@ -1,14 +1,15 @@
-﻿using GraphQL.EntityFramework;
+﻿using System.Security.Claims;
+using GraphQL.EntityFramework;
 
 class NullFilters :
     Filters
 {
     public static NullFilters Instance = new();
 
-    internal override Task<IEnumerable<TEntity>> ApplyFilter<TEntity>(IEnumerable<TEntity> result, object userContext) =>
+    internal override Task<IEnumerable<TEntity>> ApplyFilter<TEntity>(IEnumerable<TEntity> result, object userContext, ClaimsPrincipal? userPrincipal) =>
         Task.FromResult(result);
 
-    internal override Task<bool> ShouldInclude<TEntity>(object userContext, TEntity? item)
+    internal override Task<bool> ShouldInclude<TEntity>(object userContext, ClaimsPrincipal? userPrincipal, TEntity? item)
         where TEntity : class =>
         Task.FromResult(true);
 }
diff --git a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_Navigation.cs b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_Navigation.cs
@@ -35,7 +35,7 @@ public FieldBuilder<TSource, TReturn> AddNavigationField<TSource, TReturn>(
                     var fieldContext = BuildContext(context);
 
                     var result = resolve(fieldContext);
-                    if (await fieldContext.Filters.ShouldInclude(context.UserContext, result))
+                    if (await fieldContext.Filters.ShouldInclude(context.UserContext, context.User, result))
                     {
                         return result;
                     }
diff --git a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_NavigationConnection.cs b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_NavigationConnection.cs
@@ -49,7 +49,7 @@ ConnectionBuilder<TSource> AddEnumerableConnection<TSource, TGraph, TReturn>(
                 var enumerable = resolve(efFieldContext);
 
                 enumerable = enumerable.ApplyGraphQlArguments(hasId, context);
-                enumerable = await efFieldContext.Filters.ApplyFilter(enumerable, context.UserContext);
+                enumerable = await efFieldContext.Filters.ApplyFilter(enumerable, context.UserContext, context.User);
                 var page = enumerable.ToList();
 
                 return ConnectionConverter.ApplyConnectionContext(
diff --git a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_NavigationList.cs b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_NavigationList.cs
@@ -35,7 +35,7 @@ public FieldBuilder<TSource, TReturn> AddNavigationListField<TSource, TReturn>(
                     var fieldContext = BuildContext(context);
                     var result = resolve(fieldContext);
                     result = result.ApplyGraphQlArguments(hasId, context);
-                    return await fieldContext.Filters.ApplyFilter(result, context.UserContext);
+                    return await fieldContext.Filters.ApplyFilter(result, context.UserContext, context.User);
                 });
         }
 
diff --git a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_Queryable.cs b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_Queryable.cs
@@ -77,7 +77,7 @@ FieldType BuildQueryField<TSource, TReturn>(
                             .ToListAsync(context.CancellationToken);
                     }
 
-                    return await fieldContext.Filters.ApplyFilter(list, context.UserContext);
+                    return await fieldContext.Filters.ApplyFilter(list, context.UserContext, context.User);
                 });
         }
 
diff --git a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_Single.cs b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_Single.cs
@@ -98,7 +98,7 @@ FieldType BuildSingleField<TSource, TReturn>(
 
                     if (single is not null)
                     {
-                        if (await efFieldContext.Filters.ShouldInclude(context.UserContext, single))
+                        if (await efFieldContext.Filters.ShouldInclude(context.UserContext, context.User, single))
                         {
                             if (mutate is not null)
                             {
diff --git a/src/Snippets/GlobalFilterSnippets.cs b/src/Snippets/GlobalFilterSnippets.cs
@@ -20,7 +20,7 @@ public void Add(ServiceCollection services)
 
         var filters = new Filters();
         filters.Add<MyEntity>(
-            (userContext, item) => item.Property != "Ignore");
+            (userContext, userPrincipal, item) => item.Property != "Ignore");
         EfGraphQLConventions.RegisterInContainer<MyDbContext>(
             services,
             resolveFilters: x => filters);
diff --git a/src/Tests/GlobalFiltersTests.cs b/src/Tests/GlobalFiltersTests.cs
@@ -6,23 +6,23 @@ public class GlobalFiltersTests
     public async Task Simple()
     {
         var filters= new Filters();
-        filters.Add<Target>((_, target) => target.Property != "Ignore");
-        Assert.True(await filters.ShouldInclude(new(), new Target()));
-        Assert.False(await filters.ShouldInclude<object>(new(), null));
-        Assert.True(await filters.ShouldInclude(new(), new Target {Property = "Include"}));
-        Assert.False(await filters.ShouldInclude(new(), new Target {Property = "Ignore"}));
-
-        filters.Add<BaseTarget>((_, target) => target.Property != "Ignore");
-        Assert.True(await filters.ShouldInclude(new(), new ChildTarget()));
-        Assert.True(await filters.ShouldInclude(new(), new ChildTarget {Property = "Include"}));
-        Assert.False(await filters.ShouldInclude(new(), new ChildTarget {Property = "Ignore"}));
-
-        filters.Add<ITarget>((_, target) => target.Property != "Ignore");
-        Assert.True(await filters.ShouldInclude(new(), new ImplementationTarget()));
-        Assert.True(await filters.ShouldInclude(new(), new ImplementationTarget { Property = "Include"}));
-        Assert.False(await filters.ShouldInclude(new(), new ImplementationTarget { Property = "Ignore" }));
-
-        Assert.True(await filters.ShouldInclude(new(), new NonTarget { Property = "Foo" }));
+        filters.Add<Target>((_, _, target) => target.Property != "Ignore");
+        Assert.True(await filters.ShouldInclude(new(), null, new Target()));
+        Assert.False(await filters.ShouldInclude<object>(new(), null, null));
+        Assert.True(await filters.ShouldInclude(new(), null, new Target {Property = "Include"}));
+        Assert.False(await filters.ShouldInclude(new(), null, new Target {Property = "Ignore"}));
+
+        filters.Add<BaseTarget>((_, _, target) => target.Property != "Ignore");
+        Assert.True(await filters.ShouldInclude(new(), null, new ChildTarget()));
+        Assert.True(await filters.ShouldInclude(new(), null, new ChildTarget {Property = "Include"}));
+        Assert.False(await filters.ShouldInclude(new(), null, new ChildTarget {Property = "Ignore"}));
+
+        filters.Add<ITarget>((_, _, target) => target.Property != "Ignore");
+        Assert.True(await filters.ShouldInclude(new(), null, new ImplementationTarget()));
+        Assert.True(await filters.ShouldInclude(new(), null, new ImplementationTarget { Property = "Include"}));
+        Assert.False(await filters.ShouldInclude(new(), null, new ImplementationTarget { Property = "Ignore" }));
+
+        Assert.True(await filters.ShouldInclude(new(), null, new NonTarget { Property = "Foo" }));
     }
 
     public class NonTarget
diff --git a/src/Tests/IntegrationTests/IntegrationTests_filtered.cs b/src/Tests/IntegrationTests/IntegrationTests_filtered.cs
@@ -40,8 +40,8 @@ public async Task Child_filtered()
     static Filters BuildFilters()
     {
         var filters = new Filters();
-        filters.Add<FilterParentEntity>((_, item) => item.Property != "Ignore");
-        filters.Add<FilterChildEntity>((_, item) => item.Property != "Ignore");
+        filters.Add<FilterParentEntity>((_, _, item) => item.Property != "Ignore");
+        filters.Add<FilterChildEntity>((_, _, item) => item.Property != "Ignore");
         return filters;
     }
 

Original file line number	Diff line number	Diff line change
`@@ -1,25 +1,27 @@`
`1`		`-namespace GraphQL.EntityFramework;`
	`1`	`+using System.Security.Claims;`
	`2`	`+`
	`3`	`+namespace GraphQL.EntityFramework;`
`2`	`4`
`3`	`5`	`#region FiltersSignature`
`4`	`6`
`5`	`7`	`public class Filters`
`6`	`8`	`{`
`7`		`- public delegate bool Filter<in TEntity>(object userContext, TEntity input)`
	`9`	`+ public delegate bool Filter<in TEntity>(object userContext, ClaimsPrincipal? userPrincipal, TEntity input)`
`8`	`10`	`where TEntity : class;`
`9`	`11`
`10`		`- public delegate Task<bool> AsyncFilter<in TEntity>(object userContext, TEntity input)`
	`12`	`+ public delegate Task<bool> AsyncFilter<in TEntity>(object userContext, ClaimsPrincipal? userPrincipal, TEntity input)`
`11`	`13`	`where TEntity : class;`
`12`	`14`
`13`	`15`	`#endregion`
`14`	`16`
`15`	`17`	`public void Add<TEntity>(Filter<TEntity> filter)`
`16`	`18`	`where TEntity : class =>`
`17`	`19`	`funcs[typeof(TEntity)] =`
`18`		`- (context, item) =>`
	`20`	`+ (userContext, userPrincipal, item) =>`
`19`	`21`	`{`
`20`	`22`	`try`
`21`	`23`	`{`
`22`		`- return Task.FromResult(filter(context, (TEntity) item));`
	`24`	`+ return Task.FromResult(filter(userContext, userPrincipal, (TEntity) item));`
`23`	`25`	`}`
`24`	`26`	`catch (Exception exception)`
`25`	`27`	`{`
`@@ -30,23 +32,23 @@ public void Add<TEntity>(Filter<TEntity> filter)`
`30`	`32`	`public void Add<TEntity>(AsyncFilter<TEntity> filter)`
`31`	`33`	`where TEntity : class =>`
`32`	`34`	`funcs[typeof(TEntity)] =`
`33`		`- async (context, item) =>`
	`35`	`+ async (userContext, userPrincipal, item) =>`
`34`	`36`	`{`
`35`	`37`	`try`
`36`	`38`	`{`
`37`		`- return await filter(context, (TEntity) item);`
	`39`	`+ return await filter(userContext, userPrincipal, (TEntity) item);`
`38`	`40`	`}`
`39`	`41`	`catch (Exception exception)`
`40`	`42`	`{`
`41`	`43`	`throw new($"Failed to execute filter. {nameof(TEntity)}: {typeof(TEntity)}.", exception);`
`42`	`44`	`}`
`43`	`45`	`};`
`44`	`46`
`45`		`- delegate Task<bool> Filter(object userContext, object input);`
	`47`	`+ delegate Task<bool> Filter(object userContext, ClaimsPrincipal? userPrincipal, object input);`
`46`	`48`
`47`	`49`	`Dictionary<Type, Filter> funcs = new();`
`48`	`50`
`49`		`- internal virtual async Task<IEnumerable<TEntity>> ApplyFilter<TEntity>(IEnumerable<TEntity> result, object userContext)`
	`51`	`+ internal virtual async Task<IEnumerable<TEntity>> ApplyFilter<TEntity>(IEnumerable<TEntity> result, object userContext, ClaimsPrincipal? userPrincipal)`
`50`	`52`	`where TEntity : class`
`51`	`53`	`{`
`52`	`54`	`if (funcs.Count == 0)`
`@@ -63,7 +65,7 @@ internal virtual async Task<IEnumerable<TEntity>> ApplyFilter<TEntity>(IEnumerab`
`63`	`65`	`var list = new List<TEntity>();`
`64`	`66`	`foreach (var item in result)`
`65`	`67`	`{`
`66`		`- if (await ShouldInclude(userContext, item, filters))`
	`68`	`+ if (await ShouldInclude(userContext, userPrincipal, item, filters))`
`67`	`69`	`{`
`68`	`70`	`list.Add(item);`
`69`	`71`	`}`
`@@ -72,12 +74,12 @@ internal virtual async Task<IEnumerable<TEntity>> ApplyFilter<TEntity>(IEnumerab`
`72`	`74`	`return list;`
`73`	`75`	`}`
`74`	`76`
`75`		`- static async Task<bool> ShouldInclude<TEntity>(object userContext, TEntity item, List<AsyncFilter<TEntity>> filters)`
	`77`	`+ static async Task<bool> ShouldInclude<TEntity>(object userContext, ClaimsPrincipal? userPrincipal, TEntity item, List<AsyncFilter<TEntity>> filters)`
`76`	`78`	`where TEntity : class`
`77`	`79`	`{`
`78`	`80`	`foreach (var func in filters)`
`79`	`81`	`{`
`80`		`- if (!await func(userContext, item))`
	`82`	`+ if (!await func(userContext, userPrincipal, item))`
`81`	`83`	`{`
`82`	`84`	`return false;`
`83`	`85`	`}`
`@@ -86,7 +88,7 @@ static async Task<bool> ShouldInclude<TEntity>(object userContext, TEntity item,`
`86`	`88`	`return true;`
`87`	`89`	`}`
`88`	`90`
`89`		`- internal virtual async Task<bool> ShouldInclude<TEntity>(object userContext, TEntity? item)`
	`91`	`+ internal virtual async Task<bool> ShouldInclude<TEntity>(object userContext, ClaimsPrincipal? userPrincipal, TEntity? item)`
`90`	`92`	`where TEntity : class`
`91`	`93`	`{`
`92`	`94`	`if (item is null)`
`@@ -101,7 +103,7 @@ internal virtual async Task<bool> ShouldInclude<TEntity>(object userContext, TEn`
`101`	`103`
`102`	`104`	`foreach (var func in FindFilters<TEntity>())`
`103`	`105`	`{`
`104`		`- if (!await func(userContext, item))`
	`106`	`+ if (!await func(userContext, userPrincipal, item))`
`105`	`107`	`{`
`106`	`108`	`return false;`
`107`	`109`	`}`
`@@ -116,7 +118,7 @@ IEnumerable<AsyncFilter<TEntity>> FindFilters<TEntity>()`
`116`	`118`	`var type = typeof(TEntity);`
`117`	`119`	`foreach (var pair in funcs.Where(x => x.Key.IsAssignableFrom(type)))`
`118`	`120`	`{`
`119`		`- yield return (context, item) => pair.Value(context, item);`
	`121`	`+ yield return (userContext, userPrincipal, item) => pair.Value(userContext, userPrincipal, item);`
`120`	`122`	`}`
`121`	`123`	`}`
`122`	`124`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ public FieldBuilder<TSource, TReturn> AddNavigationField<TSource, TReturn>(`
`35`	`35`	`var fieldContext = BuildContext(context);`
`36`	`36`
`37`	`37`	`var result = resolve(fieldContext);`
`38`		`- if (await fieldContext.Filters.ShouldInclude(context.UserContext, result))`
	`38`	`+ if (await fieldContext.Filters.ShouldInclude(context.UserContext, context.User, result))`
`39`	`39`	`{`
`40`	`40`	`return result;`
`41`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ FieldType BuildQueryField<TSource, TReturn>(`
`77`	`77`	`.ToListAsync(context.CancellationToken);`
`78`	`78`	`}`
`79`	`79`
`80`		`- return await fieldContext.Filters.ApplyFilter(list, context.UserContext);`
	`80`	`+ return await fieldContext.Filters.ApplyFilter(list, context.UserContext, context.User);`
`81`	`81`	`});`
`82`	`82`	`}`
`83`	`83`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ FieldType BuildSingleField<TSource, TReturn>(`
`98`	`98`
`99`	`99`	`if (single is not null)`
`100`	`100`	`{`
`101`		`- if (await efFieldContext.Filters.ShouldInclude(context.UserContext, single))`
	`101`	`+ if (await efFieldContext.Filters.ShouldInclude(context.UserContext, context.User, single))`
`102`	`102`	`{`
`103`	`103`	`if (mutate is not null)`
`104`	`104`	`{`