feat(GH-219): add support for row level filtering query provider (#274)

* feat: add initial support for restricted keys query provider abstraction

* fix: code cleanup

* fix: failing IdClass query tests

* feat: add RestrictedKeysObjectProvider Spring Boot autoconfiguration

* feat: add restricted keys provider test for Relay query

* fix: polish tests

* fix: add support for restricted keys count query

* fix: add RestrictedKeysProvider Javadoc

* fix: update Javadoc

* feat: support RestricedKeysProvider for singular queries

Author: igdianov

graphql-jpa-query-boot-starter/src/main/java/com/introproventures/graphql/jpa/query/boot/autoconfigure/GraphQLJpaQueryAutoConfiguration.java

@@ -34,9 +34,11 @@
 import com.introproventures.graphql.jpa.query.schema.GraphQLExecutor;
 import com.introproventures.graphql.jpa.query.schema.GraphQLExecutorContextFactory;
 import com.introproventures.graphql.jpa.query.schema.GraphQLSchemaBuilder;
+import com.introproventures.graphql.jpa.query.schema.RestrictedKeysProvider;
 import com.introproventures.graphql.jpa.query.schema.impl.GraphQLJpaExecutor;
 import com.introproventures.graphql.jpa.query.schema.impl.GraphQLJpaExecutorContextFactory;
 import com.introproventures.graphql.jpa.query.schema.impl.GraphQLJpaSchemaBuilder;
+
 import graphql.GraphQL;
 import graphql.GraphQLContext;
 import graphql.execution.instrumentation.Instrumentation;
@@ -55,8 +57,13 @@ public static class DefaultGraphQLJpaQueryConfiguration {
         @Bean
         @ConditionalOnMissingBean
         @ConditionalOnSingleCandidate(EntityManagerFactory.class)
-        public GraphQLSchemaBuilder graphQLJpaSchemaBuilder(final EntityManagerFactory entityManagerFactory) {
-            return new GraphQLJpaSchemaBuilder(entityManagerFactory.createEntityManager());
+        public GraphQLSchemaBuilder graphQLJpaSchemaBuilder(final EntityManagerFactory entityManagerFactory,
+                                                            ObjectProvider<RestrictedKeysProvider> restrictedKeysProvider) {
+            GraphQLJpaSchemaBuilder bean = new GraphQLJpaSchemaBuilder(entityManagerFactory.createEntityManager());
+            
+            restrictedKeysProvider.ifAvailable(bean::restrictedKeysProvider);
+            
+            return bean;
         }
 
         @Bean

graphql-jpa-query-boot-starter/src/test/java/com/introproventures/graphql/jpa/query/boot/test/boot/autoconfigure/GraphQLJpaQueryAutoConfigurationTest.java

@@ -34,6 +34,7 @@
 import com.introproventures.graphql.jpa.query.schema.GraphQLExecutionInputFactory;
 import com.introproventures.graphql.jpa.query.schema.GraphQLExecutor;
 import com.introproventures.graphql.jpa.query.schema.GraphQLSchemaBuilder;
+import com.introproventures.graphql.jpa.query.schema.RestrictedKeysProvider;
 import com.introproventures.graphql.jpa.query.schema.impl.GraphQLJpaExecutor;
 import com.introproventures.graphql.jpa.query.schema.impl.GraphQLJpaExecutorContextFactory;
 import com.introproventures.graphql.jpa.query.schema.impl.GraphQLJpaSchemaBuilder;
@@ -63,6 +64,8 @@ static class Application {
         @MockBean
         private Supplier<GraphQLContext> graphqlContext;
 
+        @MockBean
+        private RestrictedKeysProvider restrictedKeysProvider;
     }
 
     @Autowired(required=false)
@@ -85,6 +88,9 @@ static class Application {
 
     @Autowired
     private ObjectProvider<Supplier<GraphQLContext>> graphqlContext;   
+
+    @Autowired
+    private ObjectProvider<RestrictedKeysProvider> restrictedKeysObjectProvider;   
 
     @Autowired
     private GraphQLSchema graphQLSchema;
@@ -96,6 +102,9 @@ public void contextIsAutoConfigured() {
 
         assertThat(graphQLSchemaBuilder).isNotNull()
                                         .isInstanceOf(GraphQLJpaSchemaBuilder.class);
+
+        assertThat(GraphQLJpaSchemaBuilder.class.cast(graphQLSchemaBuilder)
+                                                .getRestrictedKeysProvider()).isEqualTo(restrictedKeysObjectProvider.getObject());
 
         assertThat(executorContextFactory).isNotNull()
                                           .isInstanceOf(GraphQLJpaExecutorContextFactory.class);

graphql-jpa-query-schema/pom.xml

@@ -77,6 +77,18 @@
             <scope>test</scope>
         </dependency>
 
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-security</artifactId>
+            <scope>test</scope>
+        </dependency>        
+
+        <dependency>
+            <groupId>org.springframework.security</groupId>
+            <artifactId>spring-security-test</artifactId>
+            <scope>test</scope>
+        </dependency>   
+
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>

graphql-jpa-query-schema/src/main/java/com/introproventures/graphql/jpa/query/schema/RestrictedKeysProvider.java

@@ -0,0 +1,31 @@
+package com.introproventures.graphql.jpa.query.schema;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+
+import com.introproventures.graphql.jpa.query.schema.impl.EntityIntrospector.EntityIntrospectionResult;
+
+/**
+ * The RestrictedKeysProvider functional interface should provide a list of restricted keys in order to filter records  
+ * at runtime based on user security context based on EntityIntrospection descriptor. 
+ * 
+ * The return argument uses Optional<List<Object>> return type:
+ * The non-empty list will restrict the query to provided keys
+ * The empty list will run the query unrestricted. 
+ * The empty Optional will block running the query and return empty result. 
+ *
+ */
+@FunctionalInterface
+public interface RestrictedKeysProvider extends Function<EntityIntrospectionResult, Optional<List<Object>>> {
+
+    /**
+     * Applies this restricted keys provider function to the given argument of entityDescriptor.
+     *
+     * @param entityDescriptor the function argument
+     * @return the function result with optional list of keys
+     */
+    @Override
+    Optional<List<Object>> apply(EntityIntrospectionResult entityDescriptor);
+    
+}

graphql-jpa-query-schema/src/main/java/com/introproventures/graphql/jpa/query/schema/impl/GraphQLJpaQueryDataFetcher.java

@@ -23,7 +23,7 @@
 import static com.introproventures.graphql.jpa.query.support.GraphQLSupport.getSelectionField;
 import static com.introproventures.graphql.jpa.query.support.GraphQLSupport.searchByFieldName;
 
-import java.util.Collections;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 
@@ -74,21 +74,32 @@ public PagedResult<Object> get(DataFetchingEnvironment environment) {
         final PagedResult.Builder<Object> pagedResult = PagedResult.builder()
                                                                    .withOffset(firstResult)
                                                                    .withLimit(maxResults);
+        Optional<List<Object>> restrictedKeys = queryFactory.getRestrictedKeys(environment);
+        
         if (recordsSelection.isPresent()) {
-            List<Object> keys = Collections.emptyList();
-
-            if (pageArgument.isPresent() || enableDefaultMaxResults) {
-                keys = queryFactory.queryKeys(environment, firstResult, maxResults);
-            }
-
-            final List<Object> resultList = queryFactory.queryResultList(environment,
-                                                                         maxResults,
-                                                                         keys);
-            pagedResult.withSelect(resultList);
+            if (restrictedKeys.isPresent()) {
+                final List<Object> queryKeys = new ArrayList<>();
+                
+                if (pageArgument.isPresent() || enableDefaultMaxResults) {
+                    queryKeys.addAll(queryFactory.queryKeys(environment,
+                                                            firstResult,
+                                                            maxResults,
+                                                            restrictedKeys.get()));
+                } 
+                else {
+                    queryKeys.addAll(restrictedKeys.get());
+                }
+    
+                final List<Object> resultList = queryFactory.queryResultList(environment,
+                                                                             maxResults,
+                                                                             queryKeys);
+                pagedResult.withSelect(resultList);
+            } 
         }
 
         if (totalSelection.isPresent() || pagesSelection.isPresent()) {
-            final Long total = queryFactory.queryTotalCount(environment);
+            final Long total = queryFactory.queryTotalCount(environment, 
+                                                            restrictedKeys);
 
             pagedResult.withTotal(total);
         }