feat(GRAPHQL): Add language tag support in GraphQL

graphql/e2e/common/common.go

@@ -836,7 +836,7 @@ func RunAll(t *testing.T) {
 	t.Run("query id directive with int", idDirectiveWithInt)
 	t.Run("query id directive with int64", idDirectiveWithInt64)
 	t.Run("query filter ID values coercion to List", queryFilterWithIDInputCoercion)
-
+	t.Run("query multiple language Fields", queryMultipleLangFields)
 	// mutation tests
 	t.Run("add mutation", addMutation)
 	t.Run("update mutation by ids", updateMutationByIds)

graphql/e2e/common/query.go

@@ -3913,3 +3913,61 @@ func idDirectiveWithInt(t *testing.T) {
 	}`
 	require.JSONEq(t, expected, string(response.Data))
 }
+
+func queryMultipleLangFields(t *testing.T) {
+	addHotelParams := &GraphQLParams{
+		Query: `
+		mutation addPerson($person: [AddPersonInput!]!) {
+	       addPerson(input: $person) {
+	       	person {
+	       		name
+	       		nameHi
+	       		nameZh
+	       	}
+	       }
+        }`,
+		Variables: map[string]interface{}{"person": []interface{}{
+			map[string]interface{}{
+				"name":   "Alice",
+				"nameHi": "ऐलिस",
+				"nameZh": "爱丽丝",
+			},
+		},
+		},
+	}
+	gqlResponse := addHotelParams.ExecuteAsPost(t, GraphqlURL)
+	RequireNoGQLErrors(t, gqlResponse)
+
+	queryHotel := &GraphQLParams{
+		Query: `
+			query {
+	            queryPerson {
+	            	name
+	            	nameZh
+	            	nameHi
+	            	nameHiZh
+	            	nameHi_Zh_Untag
+	            	name_Untag_AnyLang
+	            }
+        }`,
+	}
+	gqlResponse = queryHotel.ExecuteAsPost(t, GraphqlURL)
+	RequireNoGQLErrors(t, gqlResponse)
+
+	queryHotelExpected := `
+	  {
+        "queryPerson": [
+            {
+                "name": "Alice",
+                "nameZh": "爱丽丝",
+                "nameHi": "ऐलिस",
+                "nameHiZh": "ऐलिस",
+                "nameHi_Zh_Untag": "ऐलिस",
+                "name_Untag_AnyLang": "Alice"
+            }
+        ]
+      }`
+	testutil.CompareJSON(t, queryHotelExpected, string(gqlResponse.Data))
+	// Cleanup
+	DeleteGqlType(t, "Person", map[string]interface{}{}, 1, nil)
+}

graphql/e2e/directives/schema.graphql

@@ -210,6 +210,16 @@ type Person1 {
     friends: [Person1] @hasInverse(field: friends)
 }
 
+type Person {
+    id: ID!
+    name: String!
+    nameHi: String @dgraph(pred:"Person.name@hi")
+    nameZh: String @dgraph(pred:"Person.name@zh")
+    nameHiZh: String @dgraph(pred:"Person.name@hi:zh")
+    nameHi_Zh_Untag: String @dgraph(pred:"Person.name@hi:zh:.")
+    name_Untag_AnyLang: String @dgraph(pred:"Person.name@.")
+}
+
 # union testing - start
 enum AnimalCategory {
 	Fish

graphql/e2e/directives/schema_response.json

@@ -94,6 +94,11 @@
       "predicate": "Employer.worker",
       "type": "uid"
     },
+    {
+      "lang": true,
+      "predicate": "Person.name",
+      "type": "string"
+    },
     {
       "predicate": "Book.chapters",
       "type": "uid",
@@ -914,6 +919,14 @@
       ],
       "name": "Home"
     },
+    {
+      "fields": [
+        {
+          "name": "Person.name"
+        }
+      ],
+      "name": "Person"
+    },
     {
       "fields": [
         {

graphql/e2e/normal/schema.graphql

@@ -163,8 +163,13 @@ type Student implements People {
 }
 
 type Person @withSubscription{
-    id: ID!
-    name: String!
+        id: ID!
+        name: String!
+        nameHi: String @dgraph(pred:"Person.name@hi")
+        nameZh: String @dgraph(pred:"Person.name@zh")
+        nameHiZh: String @dgraph(pred:"Person.name@hi:zh")
+        nameHi_Zh_Untag: String @dgraph(pred:"Person.name@hi:zh:.")
+        name_Untag_AnyLang: String @dgraph(pred:"Person.name@.")
 }
 
 """

graphql/e2e/normal/schema_response.json

@@ -414,6 +414,7 @@
       "upsert": true
     },
     {
+      "lang": true,
       "predicate": "Person.name",
       "type": "string"
     },

graphql/resolve/add_mutation_test.yaml

@@ -4520,4 +4520,25 @@
           "Friend1.id":"Main Friend",
           "dgraph.type":["Friend1"],
           "uid":"_:Friend1_1"
-       }
+       }
+
+-
+  name: "Add mutation with language tag fields"
+  gqlmutation: |
+    mutation {
+         addPerson(input: { name: "Alice", nameHi: "ऐलिस",nameZh: "爱丽丝"}) {
+           person {
+             name
+             nameZh
+             nameHi
+           }
+         }
+    }
+  dgmutations:
+    - setjson: |
+        { "Person.name":"Alice",
+          "Person.name@hi":"ऐलिस",
+          "Person.name@zh":"爱丽丝",
+          "dgraph.type": ["Person"],
+          "uid": "_:Person_1"
+        }

graphql/resolve/query_test.yaml

@@ -3382,4 +3382,30 @@
           dgraph.uid : uid
         }
       }
-    }
+    }
+
+-
+  name: "query with language tag fields"
+  gqlquery: |
+    query {
+    	queryPerson {
+    		name
+            nameZh
+            nameHi
+            nameHiZh
+            nameHi_Zh_Untag
+            name_Untag_AnyLang
+    	}
+    }
+  dgquery: |-
+    query {
+      queryPerson(func: type(Person)) {
+        Person.name : Person.name
+        Person.nameZh : Person.name@zh
+        Person.nameHi : Person.name@hi
+        Person.nameHiZh : Person.name@hi:zh
+        Person.nameHi_Zh_Untag : Person.name@hi:zh:.
+        Person.name_Untag_AnyLang : Person.name@.
+        dgraph.uid : uid
+      }
+    }

graphql/resolve/schema.graphql

@@ -310,6 +310,11 @@ type ThingTwo implements Thing {
 type Person {
     id: ID!
     name: String @search(by: [hash])
+    nameHi: String @dgraph(pred:"Person.name@hi")
+    nameZh: String @dgraph(pred:"Person.name@zh")
+    nameHiZh: String @dgraph(pred:"Person.name@hi:zh")
+    nameHi_Zh_Untag: String @dgraph(pred:"Person.name@hi:zh:.")
+    name_Untag_AnyLang: String @dgraph(pred:"Person.name@.")
     friends: [Person] @hasInverse(field: friends)
 }
 

graphql/schema/gqlschema.go

@@ -1200,7 +1200,7 @@ func addUnionMemberTypeEnum(schema *ast.Schema, defn *ast.Definition) {
 // it should be present in the addTypeInput as it should not be generated automatically by dgraph
 // but determined by the value of field in the GraphQL service where the type is defined.
 func addInputType(schema *ast.Schema, defn *ast.Definition, providesTypeMap map[string]bool) {
-	field := getFieldsWithoutIDType(schema, defn, providesTypeMap)
+	field := getFieldsWithoutIDType(schema, defn, providesTypeMap, true)
 	if hasExtends(defn) {
 		idField := getIDField(defn, providesTypeMap)
 		field = append(idField, field...)
@@ -1223,7 +1223,8 @@ func addReferenceType(schema *ast.Schema, defn *ast.Definition, providesTypeMap
 		}
 		flds = append(getIDField(defn, providesTypeMap), getXIDField(defn, providesTypeMap)...)
 	} else {
-		flds = append(getIDField(defn, providesTypeMap), getFieldsWithoutIDType(schema, defn, providesTypeMap)...)
+		flds = append(getIDField(defn, providesTypeMap),
+			getFieldsWithoutIDType(schema, defn, providesTypeMap, true)...)
 	}
 
 	if len(flds) == 1 && (hasID(defn) || hasXID(defn)) {
@@ -1571,7 +1572,7 @@ func addFilterType(schema *ast.Schema, defn *ast.Definition, providesTypeMap map
 	}
 
 	// Has filter makes sense only if there is atleast one non ID field in the defn
-	if len(getFieldsWithoutIDType(schema, defn, providesTypeMap)) > 0 {
+	if len(getFieldsWithoutIDType(schema, defn, providesTypeMap, false)) > 0 {
 		filter.Fields = append(filter.Fields,
 			&ast.FieldDefinition{Name: "has", Type: &ast.Type{Elem: &ast.Type{NamedType: defn.Name + "HasFilter"}}},
 		)
@@ -2208,7 +2209,7 @@ func getNonIDFields(schema *ast.Schema, defn *ast.Definition, providesTypeMap ma
 
 		// Ignore Fields with @external directives also as they shouldn't be present
 		// in the Patch Type also. If the field is an argument to `@provides` directive
-		// then it should be presnt.
+		// then it should be present.
 		if externalAndNonKeyField(fld, defn, providesTypeMap) {
 			continue
 		}
@@ -2217,7 +2218,12 @@ func getNonIDFields(schema *ast.Schema, defn *ast.Definition, providesTypeMap ma
 		if hasCustomOrLambda(fld) {
 			continue
 		}
-
+		// We don't include fields in update patch, which corresponds to multiple language tags in dgraph
+		// Example, nameHi_En:  String @dgraph(pred:"Person.name@hi:en")
+		// We don't add above field in update patch because it corresponds to multiple languages
+		if !isMutableLanguageField(fld) {
+			continue
+		}
 		// Remove edges which have a reverse predicate as they should only be updated through their
 		// forward edge.
 		fname := fieldName(fld, defn.Name)
@@ -2246,7 +2252,8 @@ func getNonIDFields(schema *ast.Schema, defn *ast.Definition, providesTypeMap ma
 	return append(fldList, pd)
 }
 
-func getFieldsWithoutIDType(schema *ast.Schema, defn *ast.Definition, providesTypeMap map[string]bool) ast.FieldList {
+func getFieldsWithoutIDType(schema *ast.Schema, defn *ast.Definition,
+	providesTypeMap map[string]bool, addInput bool) ast.FieldList {
 	fldList := make([]*ast.FieldDefinition, 0)
 	for _, fld := range defn.Fields {
 		if isIDField(defn, fld) {
@@ -2264,7 +2271,10 @@ func getFieldsWithoutIDType(schema *ast.Schema, defn *ast.Definition, providesTy
 		if hasCustomOrLambda(fld) {
 			continue
 		}
-
+		// see also comment in getNonIDFields
+		if !isMutableLanguageField(fld) && addInput {
+			continue
+		}
 		// Remove edges which have a reverse predicate as they should only be updated through their
 		// forward edge.
 		fname := fieldName(fld, defn.Name)
@@ -2287,6 +2297,23 @@ func getFieldsWithoutIDType(schema *ast.Schema, defn *ast.Definition, providesTy
 	return append(fldList, pd)
 }
 
+// This function check if given gql field have multiple language tags
+func isMutableLanguageField(fld *ast.FieldDefinition) bool {
+	dgDirective := fld.Directives.ForName(dgraphDirective)
+	if dgDirective != nil {
+		pred := dgDirective.Arguments.ForName("pred")
+		if pred != nil {
+			if strings.Contains(pred.Value.Raw, "@") {
+				langs := strings.Split(pred.Value.Raw, "@")[1]
+				if strings.Contains(langs, ":") || langs == "." {
+					return false
+				}
+			}
+		}
+	}
+	return true
+}
+
 func getIDField(defn *ast.Definition, providesTypeMap map[string]bool) ast.FieldList {
 	fldList := make([]*ast.FieldDefinition, 0)
 	for _, fld := range defn.Fields {

graphql/schema/gqlschema_test.yml

@@ -2889,6 +2889,68 @@ invalid_schemas:
       { "message": "Type TwitterUser; @lambdaOnMutate directive not allowed along with @remote directive.", "locations": [{"line": 1, "column": 27}]}
     ]
 
+  - name: "language tag field should be of String type"
+    input: |
+      type Person  {
+        name: String!
+        nameHi: Int @dgraph(pred:"Person.name@hi")
+      }
+    errlist: [
+      { "message": "Expected `String` type for language tag field: `nameHi` but got :`Int` inside Type `Person`", "locations": [ { "line": 3, "column": 3 } ] },
+    ]
+
+  - name: "@id directive not supported on language tag field"
+    input: |
+      type Person  {
+        name: String!
+        nameHi: String! @dgraph(pred:"Person.name@hi") @id
+      }
+    errlist: [
+      { "message": "@id directive not supported on language tag fields, field: `nameHi`,type: `Person`", "locations": [ { "line": 3, "column": 3 } ] },
+    ]
+
+  - name: "unsupported `*` language tag in graphql"
+    input: |
+      type Person  {
+        name: String!
+        nameHi: String @dgraph(pred:"Person.name@*")
+      }
+    errlist: [
+      { "message": "`*` language tag not supported in GraphQL, field: `nameHi`,type: `Person`", "locations": [ { "line": 3, "column": 3 } ] },
+    ]
+
+  - name: "untagged language field should be of type String"
+    input: |
+      type Person  {
+        name: Int!
+        nameHi: String @dgraph(pred:"Person.name@en:hi")
+      }
+    errlist: [
+      { "message": "Expected type: String, but got: `Int` for untagged language field `name` inside type: `Person`", "locations": [ { "line": 2, "column": 3 } ] },
+    ]
+
+  - name: "Incompatible exact and hash indexes are not allowed at same time on untagged and tagged languages field "
+    input: |
+      type Person  {
+        name: String! @search(by: [exact])
+        nameHi: String @dgraph(pred:"Person.name@en:hi") @search(by: [hash])
+      }
+    errlist: [
+      { "message": "Incompatible indexes hash and exact are not allowed on language tagged and untagged fields, language untagged field: `name` have exact index
+      and language tagged field `nameHi` have hash index inside type: `Person`", "locations": [ { "line": 2, "column": 3 } ] },
+    ]
+
+  - name: "Incompatible exact and hash indexes are not allowed at same time on tagged and untagged languages field, when hash index is given explicitly on untagged language field "
+    input: |
+      type Person  {
+        name: String! @search(by: [hash])
+        nameHi: String @dgraph(pred:"Person.name@en:hi") @search(by: [exact])
+      }
+    errlist: [
+      { "message": "Incompatible indexes hash and exact are not allowed on language tagged and untagged fields, language untagged field: `name` have hash index
+      and language tagged field `nameHi` have exact index inside type: `Person`", "locations": [ { "line": 2, "column": 3 } ] },
+    ]
+
 valid_schemas:
   - name: "Multiple fields with @id directive should be allowed"
     input: |