Merge pull request #5 from colinfindlay/feature/sort-limit

#4 - Adding support for Sort, Limit and Skip

Author: rashtao

src/main/java/com/arangodb/graphql/context/ArangoGraphQLContext.java

@@ -49,6 +49,12 @@ public class ArangoGraphQLContext {
 
     private int max;
 
+    private Map sort;
+
+    private Integer limit;
+
+    private Integer skip;
+
     private ArangoFilterGroup rootFilters;
     private List<ArangoFilterGroup> traversalFilters;
 
@@ -66,15 +72,45 @@ public ArangoGraphQLContext(DataFetchingEnvironment dataFetchingEnvironment, Sel
         edgeDirectives = new HashMap<>();
         rootTraversalDirection = new ArangoEdgeTraversalDirection();
 
+        setupLimit(dataFetchingEnvironment);
+        setupSort(dataFetchingEnvironment);
+
         setupRootCollection(dataFetchingEnvironment);
-        rootFilters = new ArangoRootFilterGroup(dataFetchingEnvironment.getArguments(), dataFetchingEnvironment.getFieldType());
+        Map<String, Object> filterArguments = filterArguments(dataFetchingEnvironment);
+        rootFilters = new ArangoRootFilterGroup(filterArguments, dataFetchingEnvironment.getFieldType());
         traversalFilters = new ArrayList<>();
 
         selectedFields = selectedFieldCollector.getFields();
         selectedFields.forEach(x -> processField(x));
 
     }
 
+    private Map<String, Object> filterArguments(DataFetchingEnvironment dataFetchingEnvironment){
+        Map<String, Object> arguments = dataFetchingEnvironment.getArguments();
+        arguments.remove("sort");
+        arguments.remove("limit");
+        arguments.remove("skip");
+        return arguments;
+    }
+
+    private void setupSort(DataFetchingEnvironment dataFetchingEnvironment){
+        Object sort = dataFetchingEnvironment.getArgument("sort");
+        if(sort instanceof Map){
+            this.sort = (Map) sort;
+        }
+    }
+
+    private void setupLimit(DataFetchingEnvironment dataFetchingEnvironment){
+        Object limit = dataFetchingEnvironment.getArgument("limit");
+        if(limit instanceof Integer){
+            this.limit = (Integer) limit;
+            Object skip = dataFetchingEnvironment.getArgument("skip");
+            if(skip instanceof Integer){
+                this.skip = (Integer) skip;
+            }
+        }
+    }
+
     private void setupRootCollection(DataFetchingEnvironment dataFetchingEnvironment) {
         GraphQLType rootType = GraphQLTypeUtil.unwrapAll(dataFetchingEnvironment.getFieldType());
         ArangoVertexDirective arangoVertexDirective = new ArangoVertexDirective((GraphQLDirectiveContainer) rootType);
@@ -265,4 +301,28 @@ public List<EdgeCollection> getEdgeCollections() {
     public ArangoEdgeDirective edgeDirectiveFor(String qualifiedName) {
         return edgeDirectives.get(qualifiedName);
     }
+
+    /**
+     *
+     * @return A sorted Map of top level attributes and their sort directions
+     */
+    public Map getSort() {
+        return sort;
+    }
+
+    /**
+     *
+     * @return The maximum number of top level results
+     */
+    public Integer getLimit() {
+        return limit;
+    }
+
+    /**
+     *
+     * @return The number of top level records to skip (used for pagination)
+     */
+    public Integer getSkip() {
+        return skip;
+    }
 }

src/main/java/com/arangodb/graphql/generator/DefaultArangoQueryGeneratorChain.java

@@ -47,6 +47,8 @@ public class DefaultArangoQueryGeneratorChain extends ArangoQueryGeneratorChain
     public DefaultArangoQueryGeneratorChain() {
         with(new WithGenerator());
         with(new RootForGenerator());
+        with(new SortGenerator());
+        with(new LimitGenerator());
         with(new RootFilterGenerator());
         with(new TraversalForGenerator());
         with(new EdgeCollectionGenerator());

src/main/java/com/arangodb/graphql/generator/LimitGenerator.java

@@ -0,0 +1,49 @@
+/*
+ * DISCLAIMER
+ * Copyright 2019 ArangoDB GmbH, Cologne, Germany
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright holder is ArangoDB GmbH, Cologne, Germany
+ *
+ */
+
+package com.arangodb.graphql.generator;
+
+import com.arangodb.graphql.context.ArangoFilterGroup;
+import com.arangodb.graphql.context.ArangoGraphQLContext;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * AQL Generator that will generate a LIMIT statement for the root query
+ *
+ * @author Colin Findlay
+ */
+public class LimitGenerator implements ArangoQueryGenerator {
+
+    @Override
+    public String generateAql(ArangoGraphQLContext ctx) {
+        String aql = "LIMIT ";
+        if(ctx.getSkip() != null){
+            aql = aql + ctx.getSkip() + ", ";
+        }
+        return aql + ctx.getLimit();
+    }
+
+    @Override
+    public boolean shouldGenerateFor(ArangoGraphQLContext ctx) {
+        return ctx.getLimit() != null;
+    }
+}

src/main/java/com/arangodb/graphql/generator/SortGenerator.java

@@ -0,0 +1,61 @@
+/*
+ * DISCLAIMER
+ * Copyright 2019 ArangoDB GmbH, Cologne, Germany
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright holder is ArangoDB GmbH, Cologne, Germany
+ *
+ */
+
+package com.arangodb.graphql.generator;
+
+import com.arangodb.graphql.context.ArangoGraphQLContext;
+
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * AQL Generator that will generate a SORT statement for the root query
+ *
+ * @author Colin Findlay
+ */
+public class SortGenerator implements ArangoQueryGenerator {
+
+    @Override
+    public String generateAql(ArangoGraphQLContext ctx) {
+        Map<String, String> sort = ctx.getSort();
+
+        String sortEntries = sort.entrySet()
+                .stream()
+                .map(e -> sortEntry(e.getKey(), e.getValue()))
+                .collect(Collectors.joining(", "));
+
+        String aql = "SORT " + sortEntries;
+        return aql;
+    }
+
+    private String sortEntry(String key, String value){
+        if("DESC".equals(value)) {
+            return "rootVertex." + key + " DESC";
+        }
+        else{
+            return "rootVertex." + key;
+        }
+    }
+
+    @Override
+    public boolean shouldGenerateFor(ArangoGraphQLContext ctx) {
+        return ctx.getSort() != null && ctx.getSort().size() > 0;
+    }
+}

src/main/java/com/arangodb/graphql/query/result/ResultVertices.java

@@ -23,9 +23,7 @@
 import com.arangodb.entity.BaseDocument;
 import com.arangodb.graphql.query.BaseDocumentPathEntity;
 
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 import java.util.stream.Collectors;
 
 import static java.util.stream.Collectors.toMap;
@@ -54,13 +52,16 @@ public ResultVertices(String rootCollection, List<BaseDocumentPathEntity> paths)
         vertices = paths.stream()
                 .flatMap(x -> x.getVertices().stream())
                 .filter(x -> x != null)
-                .collect(toMap(BaseDocument::getId, x -> x, (x, y) -> x));
+                .collect(toMap(BaseDocument::getId,
+                        x -> x,
+                        (x, y) -> x,
+                        LinkedHashMap::new));
 
-        rootVertices = paths.stream()
+        rootVertices = new LinkedHashSet<>(paths.stream()
                 .map(x -> x.getVertices())
                 .map(x -> x.size() > 0 ? x.get(0) : null)
                 .filter(x -> x != null)
-                .collect(Collectors.toSet());
+                .collect(Collectors.toList()));
     }
 
     /**
@@ -72,6 +73,14 @@ public BaseDocument get(String id) {
         return vertices.get(id);
     }
 
+    /**
+     * Get all vertices
+     * @return Get all vertices
+     */
+    public Map<String, BaseDocument> vertices() {
+        return vertices;
+    }
+
     /**
      * Get all the root vertices in the result
      * @return All the root vertices in the result

src/test/java/com/arangodb/graphql/context/ArangoGraphQLContextTest.java

@@ -115,6 +115,14 @@ public void setUp() throws Exception {
         when(selectedField.getQualifiedName()).thenReturn("id");
         when(selectedField.getArguments()).thenReturn(args);
 
+        when(dataFetchingEnvironment.getArgument("limit")).thenReturn(100);
+        when(dataFetchingEnvironment.getArgument("skip")).thenReturn(200);
+
+        Map sort = new HashMap();
+        sort.put("property", "ASC");
+        when(dataFetchingEnvironment.getArgument("sort")).thenReturn(sort);
+
+
         context = new ArangoGraphQLContext(dataFetchingEnvironment, selectedFieldCollector);
     }
 
@@ -195,4 +203,15 @@ public void edgeDirectiveFor() {
         assertThat(arangoEdgeDirective.getCollection(), equalTo("myEdgeCollection"));
         assertThat(arangoEdgeDirective.getDirection(), equalTo(TraversalOptions.Direction.outbound));
     }
+
+    @Test
+    public void limitAndSkip(){
+        assertThat(context.getLimit(), equalTo(100));
+        assertThat(context.getSkip(), equalTo(200));
+    }
+
+    @Test
+    public void sort(){
+        assertThat(context.getSort().get("property"), equalTo("ASC"));
+    }
 }

src/test/java/com/arangodb/graphql/generator/DefaultArangoQueryGeneratorChainTest.java

@@ -36,11 +36,13 @@ public void testDefaultChainOrder(){
 
         assertThat(chainItems.get(0), instanceOf(WithGenerator.class));
         assertThat(chainItems.get(1), instanceOf(RootForGenerator.class));
-        assertThat(chainItems.get(2), instanceOf(RootFilterGenerator.class));
-        assertThat(chainItems.get(3), instanceOf(TraversalForGenerator.class));
-        assertThat(chainItems.get(4), instanceOf(EdgeCollectionGenerator.class));
-        assertThat(chainItems.get(5), instanceOf(TraversalFilterGenerator.class));
-        assertThat(chainItems.get(6), instanceOf(ReturnStatementGenerator.class));
+        assertThat(chainItems.get(2), instanceOf(SortGenerator.class));
+        assertThat(chainItems.get(3), instanceOf(LimitGenerator.class));
+        assertThat(chainItems.get(4), instanceOf(RootFilterGenerator.class));
+        assertThat(chainItems.get(5), instanceOf(TraversalForGenerator.class));
+        assertThat(chainItems.get(6), instanceOf(EdgeCollectionGenerator.class));
+        assertThat(chainItems.get(7), instanceOf(TraversalFilterGenerator.class));
+        assertThat(chainItems.get(8), instanceOf(ReturnStatementGenerator.class));
 
     }
 

src/test/java/com/arangodb/graphql/generator/LimitGeneratorTest.java

@@ -0,0 +1,81 @@
+/*
+ * DISCLAIMER
+ * Copyright 2019 ArangoDB GmbH, Cologne, Germany
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright holder is ArangoDB GmbH, Cologne, Germany
+ *
+ */
+
+package com.arangodb.graphql.generator;
+
+import com.arangodb.graphql.context.ArangoEdgeTraversalDirection;
+import com.arangodb.graphql.context.ArangoGraphQLContext;
+import com.arangodb.graphql.model.EdgeCollection;
+import com.arangodb.model.TraversalOptions;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class LimitGeneratorTest {
+
+
+    @Mock
+    private ArangoGraphQLContext context;
+
+    private LimitGenerator generator;
+
+    @Before
+    public void setUp(){
+        generator = new LimitGenerator();
+    }
+
+    @Test
+    public void generateLimitNoSkip() {
+        when(context.getLimit()).thenReturn(100);
+        when(context.getSkip()).thenReturn(null);
+        assertThat(generator.generateAql(context), equalTo("LIMIT 100"));
+    }
+
+    @Test
+    public void generateLimitSkip() {
+        when(context.getLimit()).thenReturn(100);
+        when(context.getSkip()).thenReturn(200);
+        assertThat(generator.generateAql(context), equalTo("LIMIT 200, 100"));
+    }
+
+
+    @Test
+    public void shouldGenerateForLimit() {
+        when(context.getLimit()).thenReturn(100);
+        assertTrue(generator.shouldGenerateFor(context));
+    }
+
+
+    @Test
+    public void shouldNotGenerateForSkipOnly() {
+        when(context.getLimit()).thenReturn(null);
+        assertFalse(generator.shouldGenerateFor(context));
+    }
+}