feat(GraphQL): add has filter support (#6258)

* feat(GraphQL): Add HasFilter in the Schema (#6168)

* add HadFilter In the Schema

* fix deepsource failure

* fix Teamcity failure

* fix TestCases

* address Pawan's comments

* address Pawan's Comments

* feat(GraphQL): Add has filter in Query Rewriter (#6205)

* add has filter in query_rewriter and add test case

* remove space

* change Predicate Format and add test cases

* minor changes

* remove spaces

* change in testcases

* address Pawan's comments

* add more test cases

* fix CI failure

* add more test cases

* feat(GraphQL): add e2e tests for has filter (#6247)

* add test data

* add e2e tests

* remove spacing

* change format of has query

* change addPost mutation

* fix test failures

* fix has filter test failure

Author: minhaj-shakeel

graphql/e2e/common/common.go

@@ -243,11 +243,13 @@ func RunAll(t *testing.T) {
 	t.Run("multiple search indexes wrong field", multipleSearchIndexesWrongField)
 	t.Run("hash search", hashSearch)
 	t.Run("deep filter", deepFilter)
+	t.Run("deep has filter", deepHasFilter)
 	t.Run("many queries", manyQueries)
 	t.Run("query order at root", queryOrderAtRoot)
 	t.Run("queries with error", queriesWithError)
 	t.Run("date filters", dateFilters)
 	t.Run("float filters", floatFilters)
+	t.Run("has filters", hasFilters)
 	t.Run("Int filters", int32Filters)
 	t.Run("Int64 filters", int64Filters)
 	t.Run("boolean filters", booleanFilters)

graphql/e2e/common/mutation.go

@@ -780,6 +780,80 @@ func addPost(t *testing.T, authorID, countryID string,
 	return result.AddPost.Post[0]
 }
 
+func addPostWithNullText(t *testing.T, authorID, countryID string,
+	executeRequest requestExecutor) *post {
+
+	addPostParams := &GraphQLParams{
+		Query: `mutation addPost($post: AddPostInput!) {
+			addPost(input: [$post]) {
+			  post( filter : {not :{has : text} }){
+				postID
+				title
+				text
+				isPublished
+				tags
+				author(filter: {has:country}) {
+					id
+					name
+					country {
+						id
+						name
+					}
+				}
+			  }
+			}
+		}`,
+		Variables: map[string]interface{}{"post": map[string]interface{}{
+			"title":       "No text",
+			"isPublished": false,
+			"numLikes":    0,
+			"tags":        []string{"no text", "null"},
+			"author":      map[string]interface{}{"id": authorID},
+		}},
+	}
+
+	addPostExpected := fmt.Sprintf(`{ "addPost": {
+		"post": [{
+			"postID": "_UID_",
+			"title": "No text",
+			"text": null,
+			"isPublished": false,
+			"tags": ["null","no text"],
+			"numLikes": 0,
+			"author": {
+				"id": "%s",
+				"name": "Test Author",
+				"country": {
+					"id": "%s",
+					"name": "Testland"
+				}
+			}
+		}]
+	} }`, authorID, countryID)
+
+	gqlResponse := executeRequest(t, graphqlURL, addPostParams)
+	RequireNoGQLErrors(t, gqlResponse)
+
+	var expected, result struct {
+		AddPost struct {
+			Post []*post
+		}
+	}
+	err := json.Unmarshal([]byte(addPostExpected), &expected)
+	require.NoError(t, err)
+	err = json.Unmarshal([]byte(gqlResponse.Data), &result)
+	require.NoError(t, err)
+
+	requireUID(t, result.AddPost.Post[0].PostID)
+
+	opt := cmpopts.IgnoreFields(post{}, "PostID")
+	if diff := cmp.Diff(expected, result, opt); diff != "" {
+		t.Errorf("result mismatch (-want +got):\n%s", diff)
+	}
+
+	return result.AddPost.Post[0]
+}
+
 func requirePost(
 	t *testing.T,
 	postID string,

graphql/e2e/common/query.go

@@ -378,6 +378,43 @@ func deepFilter(t *testing.T) {
 	}
 }
 
+func deepHasFilter(t *testing.T) {
+	newCountry := addCountry(t, postExecutor)
+	newAuthor := addAuthor(t, newCountry.ID, postExecutor)
+	newPost1 := addPostWithNullText(t, newAuthor.ID, newCountry.ID, postExecutor)
+	newPost2 := addPost(t, newAuthor.ID, newCountry.ID, postExecutor)
+	getAuthorParams := &GraphQLParams{
+		Query: `query {
+			queryAuthor(filter: { name: { eq: "Test Author" } }) {
+				name
+				posts(filter: {not :{ has : text } }) {
+					title
+				}
+			}
+		}`,
+	}
+
+	gqlResponse := getAuthorParams.ExecuteAsPost(t, graphqlURL)
+	RequireNoGQLErrors(t, gqlResponse)
+
+	var result struct {
+		QueryAuthor []*author
+	}
+	err := json.Unmarshal([]byte(gqlResponse.Data), &result)
+	require.NoError(t, err)
+	require.Equal(t, 1, len(result.QueryAuthor))
+
+	expected := &author{
+		Name:  "Test Author",
+		Posts: []*post{{Title: "No text"}},
+	}
+
+	if diff := cmp.Diff(expected, result.QueryAuthor[0]); diff != "" {
+		t.Errorf("result mismatch (-want +got):\n%s", diff)
+	}
+	cleanUp(t, []*country{newCountry}, []*author{newAuthor}, []*post{newPost1, newPost2})
+}
+
 // manyQueries runs multiple queries in the one block.  Internally, the GraphQL
 // server should run those concurrently, but the results should be returned in the
 // requested order.  This makes sure those many test runs are reassembled correctly.
@@ -699,6 +736,22 @@ func int32Filters(t *testing.T) {
 	}
 }
 
+func hasFilters(t *testing.T) {
+	newCountry := addCountry(t, postExecutor)
+	newAuthor := addAuthor(t, newCountry.ID, postExecutor)
+	newPost := addPostWithNullText(t, newAuthor.ID, newCountry.ID, postExecutor)
+
+	Filter := map[string]interface{}{"has": "text"}
+	Expected := []*post{
+		{Title: "GraphQL doco"},
+		{Title: "Introducing GraphQL in Dgraph"},
+		{Title: "Learning GraphQL in Dgraph"},
+		{Title: "Random post"}}
+
+	postTest(t, Filter, Expected)
+	cleanUp(t, []*country{newCountry}, []*author{newAuthor}, []*post{newPost})
+}
+
 func int64Filters(t *testing.T) {
 	cases := map[string]struct {
 		Filter   interface{}

graphql/resolve/query_rewriter.go

@@ -971,7 +971,6 @@ func buildFilter(typ schema.Type, filter map[string]interface{}) *gql.FilterTree
 
 	var ands []*gql.FilterTree
 	var or *gql.FilterTree
-
 	// Get a stable ordering so we generate the same thing each time.
 	var keys []string
 	for key := range filter {
@@ -1041,19 +1040,35 @@ func buildFilter(typ schema.Type, filter map[string]interface{}) *gql.FilterTree
 					},
 				})
 			case interface{}:
+				// has: comments -> has(Post.comments)
+				// OR
 				// isPublished: true -> eq(Post.isPublished, true)
 				// OR an enum case
 				// postType: Question -> eq(Post.postType, "Question")
-				fn := "eq"
-				ands = append(ands, &gql.FilterTree{
-					Func: &gql.Function{
-						Name: fn,
-						Args: []gql.Arg{
-							{Value: typ.DgraphPredicate(field)},
-							{Value: fmt.Sprintf("%v", dgFunc)},
+				switch field {
+				case "has":
+					fieldName := fmt.Sprintf("%v", dgFunc)
+					ands = append(ands, &gql.FilterTree{
+						Func: &gql.Function{
+							Name: field,
+							Args: []gql.Arg{
+								{Value: typ.DgraphPredicate(fieldName)},
+							},
 						},
-					},
-				})
+					})
+
+				default:
+					fn := "eq"
+					ands = append(ands, &gql.FilterTree{
+						Func: &gql.Function{
+							Name: fn,
+							Args: []gql.Arg{
+								{Value: typ.DgraphPredicate(field)},
+								{Value: fmt.Sprintf("%v", dgFunc)},
+							},
+						},
+					})
+				}
 			}
 		}
 	}

graphql/resolve/query_test.yaml

@@ -167,6 +167,54 @@
       }
     }
 
+-
+  name: "Query with has Filter"
+  gqlquery: |
+    query {
+      queryTeacher(filter: {has: subject}) {
+        name
+      }
+    }
+  dgquery: |-
+    query {
+      queryTeacher(func: type(Teacher)) @filter(has(Teacher.subject)) {
+        name : People.name
+        dgraph.uid : uid
+      }
+    }
+
+-
+  name: "has Filter with not"
+  gqlquery: |
+    query {
+      queryTeacher(filter: { not : {has: subject } }) {
+        name
+      }
+    }
+  dgquery: |-
+    query {
+      queryTeacher(func: type(Teacher)) @filter(NOT (has(Teacher.subject))) {
+        name : People.name
+        dgraph.uid : uid
+      }
+    }
+
+-
+  name: "has Filter with and"
+  gqlquery: |
+    query {
+      queryTeacher(filter: {has: subject, and: {has: teaches } }  ) {
+        name
+      }
+    }
+  dgquery: |-
+    query {
+      queryTeacher(func: type(Teacher)) @filter((has(Teacher.teaches) AND has(Teacher.subject))) {
+        name : People.name
+        dgraph.uid : uid
+      }
+    }
+
 -
   name: "Filters in same input object implies AND"
   gqlquery: |
@@ -199,6 +247,22 @@
       }
     }
 
+-
+  name: "has Filter with nested 'and'"
+  gqlquery: |
+    query {
+      queryAuthor(filter: { name: { eq: "A. N. Author" }, and: { dob: { le: "2001-01-01" }, and: { has: country } } } ) {
+        name
+      }
+    }
+  dgquery: |-
+    query {
+      queryAuthor(func: type(Author)) @filter(((has(Author.country) AND le(Author.dob, "2001-01-01")) AND eq(Author.name, "A. N. Author"))) {
+        name : Author.name
+        dgraph.uid : uid
+      }
+    }
+
 -
   name: "Filter with 'or'"
   gqlquery: |
@@ -401,6 +465,51 @@
     }
 
 
+-
+  name: "Deep filter with has filter"
+  gqlquery: |
+    query {
+      queryAuthor {
+        name
+        posts(filter: { has : tags }) {
+          title
+        }
+      }
+    }
+  dgquery: |-
+    query {
+      queryAuthor(func: type(Author)) {
+        name : Author.name
+        posts : Author.posts @filter(has(Post.tags)) {
+          title : Post.title
+          dgraph.uid : uid
+        }
+        dgraph.uid : uid
+      }
+    }
+
+-
+  name: "Deep filter with has and other filters"
+  gqlquery: |
+    query {
+      queryAuthor {
+        name
+        posts(filter:{ title : {anyofterms: "GRAPHQL"} , and : { has : tags } } ) {
+          title
+        }
+      }
+    }
+  dgquery: |-
+    query {
+      queryAuthor(func: type(Author)) {
+        name : Author.name
+        posts : Author.posts @filter((has(Post.tags) AND anyofterms(Post.title, "GRAPHQL"))) {
+          title : Post.title
+          dgraph.uid : uid
+        }
+        dgraph.uid : uid
+      }
+    }
 -
   name: "Deep filter with first"
   gqlquery: |
@@ -1445,4 +1554,4 @@
       queryThingOne(func: type(ThingOne)) {
         dgraph.uid : uid
       }
-    }
+    }