Feat(GraphQL): This PR adds parameterised cascade in graphql.

graphql/dgraph/graphquery.go

@@ -72,6 +72,10 @@ func writeQuery(b *strings.Builder, query *gql.GraphQuery, prefix string) {
 	if len(query.Cascade) != 0 {
 		if query.Cascade[0] == "__all__" {
 			x.Check2(b.WriteString(" @cascade"))
+		} else {
+			x.Check2(b.WriteString(" @cascade("))
+			x.Check2(b.WriteString(strings.Join(query.Cascade, ", ")))
+			x.Check2(b.WriteRune(')'))
 		}
 	}
 

graphql/e2e/common/error_test.yaml

@@ -89,7 +89,7 @@
     [ { "message": "must be defined",
       "path": [ "variable", "filter"] } ]
 -
-  name: "subscription on type without @withSubscription directive should retur error"
+  name: "subscription on type without @withSubscription directive should return error"
   gqlrequest: |
     subscription {
       getAuthor(id: "0x1") { name }
@@ -100,3 +100,33 @@
     [ { "message": "Cannot query field \"getAuthor\" on type \"Subscription\".",
         "locations": [ { "line": 2, "column": 3 } ] } ]
 
+-
+  name: "@cascade only accepts those fields as a argument, which are present in given type "
+  gqlrequest: |
+    query {
+      queryAuthor @cascade(fields:["title"]){
+        dob
+        reputation
+      }
+    }
+  gqlvariables:
+    { }
+  errors:
+    [ { "message": "Field `title` is not present in type `Author`. You can only use fields which are in type `Author`",
+    } ]
+
+-
+  name: "@cascade only accepts numUids or given type name as arguments for add or update payload "
+  gqlrequest: |
+    mutation {
+      addAuthor(input:[{name:"jatin"}]) @cascade(fields:["name"]) {
+        author {
+          name
+            }
+          }
+      }
+  gqlvariables:
+    { }
+  errors:
+    [ { "message": "Field `name` is not present in type `AddAuthorPayload`. You can only use fields which are in type `AddAuthorPayload`",
+    } ]

graphql/e2e/common/query.go

@@ -1743,7 +1743,7 @@ func DgraphDirectiveWithSpecialCharacters(t *testing.T) {
 }
 
 func queryWithCascade(t *testing.T) {
-	// for testing @cascade with get by ID and filter queries, also for testing @cascade on field
+	// for testing normal and parameterized @cascade with get by ID and filter queries on multiple levels
 	authors := addMultipleAuthorFromRef(t, []*author{
 		{
 			Name:       "George",
@@ -1752,15 +1752,20 @@ func queryWithCascade(t *testing.T) {
 		}, {
 			Name:       "Jerry",
 			Reputation: 4.6,
+			Country:    &country{Name: "outer Galaxy2"},
 			Posts:      []*post{{Title: "Outside", Tags: []string{}}},
 		}, {
-			Name:  "Kramer",
-			Posts: []*post{{Title: "Ha! Cosmo Kramer", Text: "Giddy up!", Tags: []string{}}},
+			Name:    "Kramer",
+			Country: &country{Name: "outer space2"},
+			Posts:   []*post{{Title: "Ha! Cosmo Kramer", Text: "Giddy up!", Tags: []string{}}},
 		},
 	}, postExecutor)
+	newStarship := addStarship(t)
+	humanID := addHuman(t, newStarship.ID)
 	authorIds := []string{authors[0].ID, authors[1].ID, authors[2].ID}
 	postIds := []string{authors[0].Posts[0].PostID, authors[1].Posts[0].PostID,
 		authors[2].Posts[0].PostID}
+	countryIds := []string{authors[1].Country.ID, authors[2].Country.ID}
 	getAuthorByIdQuery := `query ($id: ID!) {
 							  getAuthor(id: $id) @cascade {
 								reputation
@@ -1881,6 +1886,159 @@ func queryWithCascade(t *testing.T) {
 							}]
 						}`,
 		},
+		{
+			name: "parameterized cascade with argument at outer level only",
+			query: `query ($ids: [ID!]) {
+					  queryAuthor(filter: {id: $ids})  @cascade(fields:["name"]) {
+						reputation
+                        name
+						country {
+                          name
+						}
+					  }
+					}`,
+			variables: map[string]interface{}{"ids": authorIds},
+			respData: `{
+							"queryAuthor": [{
+								"reputation": 4.6,
+								 "name":"Jerry",
+								"country": {
+									"name": "outer Galaxy2"
+								}
+							},{
+								 "name":"Kramer",
+                                 "reputation": null,
+								"country": {
+									"name": "outer space2"
+								}
+							},{ 
+								"reputation": 4.5,
+								 "name":"George",
+								 "country": null
+							}]
+						}`,
+		},
+		{
+			name: "parameterized cascade only at inner level ",
+			query: `query ($ids: [ID!]) {
+					  queryAuthor(filter: {id: $ids})  {
+						reputation
+                        name
+						posts @cascade(fields:["text"]) {
+						  title
+						  text
+						}
+					  }
+					}`,
+			variables: map[string]interface{}{"ids": authorIds},
+			respData: `{
+							"queryAuthor": [{
+								"reputation": 4.5,
+								 "name":"George",
+								"posts": [{
+									"title": "A show about nothing",
+									"text": "Got ya!"
+								}]
+							},{
+                                "name":"Kramer",
+                                "reputation": null,
+								"posts": [{
+									"title": "Ha! Cosmo Kramer",
+									"text": "Giddy up!"
+								}]
+							},{
+                                "name":"Jerry",
+								"reputation": 4.6,
+								"posts": []
+                            }]
+						}`,
+		},
+		{
+			name: "parameterized cascade at all levels ",
+			query: `query ($ids: [ID!]) {
+					  queryAuthor(filter: {id: $ids}) @cascade(fields:["reputation","name"]) {
+						reputation
+                        name
+                        dob
+						posts @cascade(fields:["text"]) {
+						  title
+						  text
+						}
+					  }
+					}`,
+			variables: map[string]interface{}{"ids": authorIds},
+			respData: `{
+							"queryAuthor": [{
+								"reputation": 4.5,
+								 "name":"George",
+                                 "dob": null,
+								"posts": [{
+									"title": "A show about nothing",
+									"text": "Got ya!"
+								}]
+							}, {
+                                  "dob": null,
+                                  "name": "Jerry",
+                                  "posts": [],
+                                  "reputation": 4.6
+							}]
+						}`,
+		},
+		{
+			name: "parameterized cascade on ID type ",
+			query: `query ($ids: [ID!]) {
+					  queryAuthor(filter: {id: $ids}) @cascade(fields:["reputation","id"]) {
+						reputation
+                        name
+                        dob
+					  }
+					}`,
+			variables: map[string]interface{}{"ids": authorIds},
+			respData: `{
+							"queryAuthor": [{
+								"reputation": 4.5,
+								 "name":"George",
+                                 "dob": null
+							}, {
+                                  "dob": null,
+                                  "name": "Jerry",
+                                  "reputation": 4.6
+							}]
+						}`,
+		},
+		{
+			name: "parameterized cascade on field of interface ",
+			query: `query  {
+					  queryHuman() @cascade(fields:["name"]) {
+                      name
+                      totalCredits
+					  }
+					}`,
+			respData: `{
+							"queryHuman": [{
+								"name": "Han",
+								"totalCredits":10
+							}]
+						}`,
+		},
+		{
+			name: "parameterized cascade on interface ",
+			query: `query {
+                    	queryCharacter (filter: { appearsIn: { eq: [EMPIRE] } }) @cascade(fields:["appearsIn"])
+                        {
+                        	name
+                            appearsIn
+               			} 
+		     		 }`,
+			respData: `{
+							"queryCharacter": [{
+								"name": "Han",
+								"appearsIn":[
+                                   "EMPIRE"
+								]
+							}]
+						}`,
+		},
 	}
 
 	for _, tcase := range tcases {
@@ -1897,7 +2055,9 @@ func queryWithCascade(t *testing.T) {
 
 	// cleanup
 	deleteAuthors(t, authorIds, nil)
+	deleteCountry(t, map[string]interface{}{"id": countryIds}, len(countryIds), nil)
 	deleteGqlType(t, "Post", map[string]interface{}{"postID": postIds}, len(postIds), nil)
 	deleteState(t, getXidFilter("xcode", []string{states[0].Code, states[1].Code}), len(states),
 		nil)
+	cleanupStarwars(t, newStarship.ID, humanID, "")
 }

graphql/resolve/mutation_query_test.yaml

@@ -237,6 +237,121 @@ ADD_UPDATE_MUTATION:
         }
       }
 
+  -
+    name: "parameterized cascade directive on mutation payload"
+    gqlquery: |
+      mutation {
+        ADD_UPDATE_MUTATION @cascade(fields:["post","numUids"]) {
+          post {
+            title
+            text
+            author {
+              name
+              dob
+            }
+          }
+        }
+      }
+    dgquery: |-
+      query {
+        post(func: uid(0x4)) @cascade {
+          title : Post.title
+          text : Post.text
+          author : Post.author {
+            name : Author.name
+            dob : Author.dob
+            dgraph.uid : uid
+          }
+          dgraph.uid : uid
+        }
+      }
+
+  -
+    name: "parametrized cascade directive on mutation query field"
+    gqlquery: |
+      mutation {
+        ADD_UPDATE_MUTATION  {
+          post @cascade(fields:["title","text"]) {
+            title
+            text
+            author {
+              name
+              dob
+            }
+          }
+        }
+      }
+    dgquery: |-
+      query {
+        post(func: uid(0x4)) @cascade(Post.title, Post.text) {
+          title : Post.title
+          text : Post.text
+          author : Post.author {
+            name : Author.name
+            dob : Author.dob
+            dgraph.uid : uid
+          }
+          dgraph.uid : uid
+        }
+      }
+
+  -
+    name: "parameterized cascade directive inside mutation query"
+    gqlquery: |
+      mutation {
+        ADD_UPDATE_MUTATION {
+          post {
+            title
+            text
+            author @cascade(fields:["name","dob"]) {
+              name
+              dob
+            }
+          }
+        }
+      }
+    dgquery: |-
+      query {
+        post(func: uid(0x4)) {
+          title : Post.title
+          text : Post.text
+          author : Post.author @cascade(Author.name, Author.dob) {
+            name : Author.name
+            dob : Author.dob
+            dgraph.uid : uid
+          }
+          dgraph.uid : uid
+        }
+      }
+
+  -
+    name: "parameterized cascade directive at multiple levels "
+    gqlquery: |
+      mutation {
+        ADD_UPDATE_MUTATION @cascade(fields:["post"]) {
+          post {
+            title
+            text
+            author @cascade(fields:["name","dob"]) {
+              name
+              dob
+            }
+          }
+        }
+      }
+    dgquery: |-
+      query {
+        post(func: uid(0x4)) @cascade {
+          title : Post.title
+          text : Post.text
+          author : Post.author @cascade(Author.name, Author.dob) {
+            name : Author.name
+            dob : Author.dob
+            dgraph.uid : uid
+          }
+          dgraph.uid : uid
+        }
+      }
 UPDATE_MUTATION:
   -
     name: "filter update result"