feat(GraphQL): Extend Support For Apollo Federation (#7275)

This PR extends support for the `Apollo Federation`.

## Support for Apollo federation directives
Our current implementation allows support for 3 directives, namely @key, @extends and @external.
### @key directive.
This directive is used on any type  and it takes one field argument inside it which is called @key field. There are some limitations on how to use @key directives.  
* User can define @key directive only once for a type, Support for multiple key types is not provided yet. 
* Since the @key field act as a foreign key to resolve entities from the service where it is extended, the field provided as an argument inside @key directive should be of `ID` type or having `@id` directive on it. For example:-
```
type User @key(fields: "id") {
   id: ID!
  name: String
}
```
### @extends directive.
@extends directive is provided to give support for extended definitions. Suppose the above defined `User` type is defined in some service. Users can extend it to our GraphQL service by using this keyword.
```
type User @key(fields: "id") @extends{
   id: ID! @external
  products: [Product]
}
```
### @external directive.
@external directive means that the given field is not stored on this service. It is stored in some other service. This keyword can only be used on extended type definitions. Like it is used above on the `id` field.

## Generated Queries and mutations
In this section, we will mention what all the queries and mutations will be available to individual service and to the apollo `gateway`. We will take the given schema as our example:-
```
type Mission @key(fields: "id") {
    id: ID!
    crew: [Astronaut]
    designation: String!
    startDate: String
    endDate: String
}

type Astronaut @key(fields: "id") @extends {
    id: ID! @external
    missions: [Mission]
}
```
The queries and mutations which are exposed to the gateway are:-
```
type Query {
	getMission(id: ID!): Mission
	queryMission(filter: MissionFilter, order: MissionOrder, first: Int, offset: Int): [Mission]
	aggregateMission(filter: MissionFilter): MissionAggregateResult
}

type Mutation {
	addMission(input: [AddMissionInput!]!): AddMissionPayload
	updateMission(input: UpdateMissionInput!): UpdateMissionPayload
	deleteMission(filter: MissionFilter!): DeleteMissionPayload
	addAstronaut(input: [AddAstronautInput!]!): AddAstronautPayload
	updateAstronaut(input: UpdateAstronautInput!): UpdateAstronautPayload
	deleteAstronaut(filter: AstronautFilter!): DeleteAstronautPayload
}
```
The queries for `Astronaut` are not exposed to the gateway since it will be resolved through the `_entities` resolver. Although these queries will be available on the Dgraph GraphQL endpoint.

# Mutation for `extended` types
if we want to add an object of Astronaut type which is @Extended in this service.
The mutation `addAstronaut` takes `AddAstronautInput` which is generated as:-
```
input AddAstronautInput {
	id: ID!
	missions: [MissionRef]
}
```
Even though the `id` field is of `ID` type which should be ideally be generated internally by Dgraph, In this case, it should be provided as input. The reason for this is because of the unavailability of `federated mutations`, the user should provide the value of `id` same as the value present in the GraphQL service where the type `Astronaut` is defined.
For example, let's take that the type Astronaut is defined in some other service `AstronautService` as:-
```
type Astronaut @key(fields: "id") {
    id: ID! 
    name: String!
}
```
When adding an Object of `Astronaut` type, first it should be added into `AstronautService` and then the `addAstronaut` mutation should be called and value of `id` provided as an argument must be equal to the value in `AstronautService`. 

# Gateway Supported Directives.
Due to the bug in the federation library (see [here](apollographql/federation#346)), some directives are removed from the schema `SDL` which is returned to the gateway in response to the `_service` query.
Those directives are `@custom`, `@generate`, and `@auth`. 
You can still use these directives in your GraphQL schema and they will work as desired but the gateway will unaware of this.

Author: minhaj-shakeel

graphql/admin/admin.go

@@ -379,7 +379,7 @@ var (
 )
 
 func SchemaValidate(sch string) error {
-	schHandler, err := schema.NewHandler(sch, true)
+	schHandler, err := schema.NewHandler(sch, true, false)
 	if err != nil {
 		return err
 	}
@@ -639,7 +639,7 @@ func getCurrentGraphQLSchema() (*gqlSchema, error) {
 }
 
 func generateGQLSchema(sch *gqlSchema) (schema.Schema, error) {
-	schHandler, err := schema.NewHandler(sch.Schema, false)
+	schHandler, err := schema.NewHandler(sch.Schema, false, false)
 	if err != nil {
 		return nil, err
 	}
@@ -837,6 +837,7 @@ func resolverFactoryWithErrorMsg(msg string) resolve.ResolverFactory {
 	return resolve.NewResolverFactory(qErr, mErr)
 }
 
+// Todo(Minhaj): Fetch NewHandler for service query only once
 func (as *adminServer) resetSchema(gqlSchema schema.Schema) {
 	// set status as updating schema
 	mainHealthStore.updatingSchema()
@@ -850,6 +851,26 @@ func (as *adminServer) resetSchema(gqlSchema schema.Schema) {
 	} else {
 		resolverFactory = resolverFactoryWithErrorMsg(errResolverNotFound).
 			WithConventionResolvers(gqlSchema, as.fns)
+		// If the schema is a Federated Schema then attach "_service" resolver
+		if gqlSchema.IsFederated() {
+			resolverFactory.WithQueryResolver("_service", func(s schema.Query) resolve.QueryResolver {
+				return resolve.QueryResolverFunc(func(ctx context.Context, query schema.Query) *resolve.Resolved {
+					as.mux.RLock()
+					defer as.mux.RUnlock()
+					sch := as.schema.Schema
+					handler, err := schema.NewHandler(sch, false, true)
+					if err != nil {
+						return resolve.EmptyResult(query, err)
+					}
+					data := handler.GQLSchemaWithoutApolloExtras()
+					return &resolve.Resolved{
+						Data:  map[string]interface{}{"_service": map[string]interface{}{"sdl": data}},
+						Field: query,
+					}
+				})
+			})
+		}
+
 		if as.withIntrospection {
 			resolverFactory.WithSchemaIntrospection()
 		}

graphql/admin/schema.go

@@ -57,7 +57,7 @@ func (usr *updateSchemaResolver) Resolve(ctx context.Context, m schema.Mutation)
 
 	// We just need to validate the schema. Schema is later set in `resetSchema()` when the schema
 	// is returned from badger.
-	schHandler, err := schema.NewHandler(input.Set.Schema, true)
+	schHandler, err := schema.NewHandler(input.Set.Schema, true, false)
 	if err != nil {
 		return resolve.EmptyResult(m, err), false
 	}

graphql/dgraph/graphquery.go

@@ -137,7 +137,8 @@ func writeUIDFunc(b *strings.Builder, uids []uint64, args []gql.Arg) {
 // writeRoot writes the root function as well as any ordering and paging
 // specified in q.
 //
-// Only uid(0x123, 0x124) and type(...) functions are supported at root.
+// Only uid(0x123, 0x124), type(...) and eq(Type.Predicate, ...) functions are supported at root.
+// Multiple arguments for `eq` filter will be required in case of resolving `entities` query.
 func writeRoot(b *strings.Builder, q *gql.GraphQuery) {
 	if q.Func == nil {
 		return
@@ -149,9 +150,10 @@ func writeRoot(b *strings.Builder, q *gql.GraphQuery) {
 		writeUIDFunc(b, q.Func.UID, q.Func.Args)
 	case q.Func.Name == "type" && len(q.Func.Args) == 1:
 		x.Check2(b.WriteString(fmt.Sprintf("(func: type(%s)", q.Func.Args[0].Value)))
-	case q.Func.Name == "eq" && len(q.Func.Args) == 2:
-		x.Check2(b.WriteString(fmt.Sprintf("(func: eq(%s, %s)", q.Func.Args[0].Value,
-			q.Func.Args[1].Value)))
+	case q.Func.Name == "eq":
+		x.Check2(b.WriteString("(func: eq("))
+		writeFilterArguments(b, q.Func.Args)
+		x.Check2(b.WriteRune(')'))
 	}
 	writeOrderAndPage(b, q, true)
 	x.Check2(b.WriteRune(')'))

graphql/e2e/auth/schema.graphql

@@ -775,3 +775,31 @@ type Book @auth(
     name: String!
     desc: String!
 }
+
+
+type Mission @key(fields: "id") @auth(
+    query:{ rule: """
+            query($USER: String!) { 
+              queryMission(filter: { supervisorName: {eq: $USER} } ) { 
+                id 
+              } 
+            }""" }
+){
+    id: String! @id
+    crew: [Astronaut]
+    supervisorName: String @search(by: [exact])
+    designation: String!
+    startDate: String
+    endDate: String
+}
+
+type Astronaut @key(fields: "id") @extends @auth(
+    query: { rule: "{$ROLE: { eq: \"admin\" } }"},
+    add: { rule: "{$USER: { eq: \"foo\" } }"},
+    delete: { rule: "{$USER: { eq: \"foo\" } }"},
+    update: { rule: "{$USER: { eq: \"foo\" } }"}
+){
+    id: ID! @external
+    missions: [Mission]
+}
+

graphql/e2e/common/common.go

@@ -137,6 +137,11 @@ type country struct {
 	States []*state `json:"states,omitempty"`
 }
 
+type mission struct {
+	ID          string `json:"id,omitempty"`
+	Designation string `json:"designation,omitempty"`
+}
+
 type author struct {
 	ID            string     `json:"id,omitempty"`
 	Name          string     `json:"name,omitempty"`
@@ -630,6 +635,7 @@ func RunAll(t *testing.T) {
 	t.Run("query only typename", queryOnlyTypename)
 	t.Run("query nested only typename", querynestedOnlyTypename)
 	t.Run("test onlytypename for interface types", onlytypenameForInterface)
+	t.Run("entitites Query on extended type", entitiesQuery)
 
 	t.Run("get state by xid", getStateByXid)
 	t.Run("get state without args", getStateWithoutArgs)
@@ -713,6 +719,8 @@ func RunAll(t *testing.T) {
 	t.Run("mutation id directive with int", idDirectiveWithIntMutation)
 	t.Run("mutation id directive with int64", idDirectiveWithInt64Mutation)
 	t.Run("mutation id directive with float", idDirectiveWithFloatMutation)
+	t.Run("add mutation on extended type with field of ID type as key field", addMutationOnExtendedTypeWithIDasKeyField)
+	t.Run("add mutation with deep extended type objects", addMutationWithDeepExtendedTypeObjects)
 
 	// error tests
 	t.Run("graphql completion on", graphQLCompletionOn)

graphql/e2e/common/mutation.go

@@ -4674,3 +4674,149 @@ func idDirectiveWithFloatMutation(t *testing.T) {
 
 	DeleteGqlType(t, "Section", map[string]interface{}{}, 4, nil)
 }
+
+func addMutationWithDeepExtendedTypeObjects(t *testing.T) {
+	varMap1 := map[string]interface{}{
+		"missionId":   "Mission1",
+		"astronautId": "Astronaut1",
+		"des":         "Apollo1",
+	}
+	addMissionParams := &GraphQLParams{
+		Query: `mutation addMission($missionId: String!, $astronautId: ID!, $des: String!) {
+			addMission(input: [{id: $missionId, designation: $des, crew: [{id: $astronautId}]}]) {
+				mission{
+					id
+					crew {
+						id
+						missions(order: {asc: id}){
+							id
+						}
+					}
+				}
+			}
+		}
+		`,
+		Variables: varMap1,
+	}
+	gqlResponse := addMissionParams.ExecuteAsPost(t, GraphqlURL)
+	RequireNoGQLErrors(t, gqlResponse)
+
+	expectedJSON := `{
+		"addMission": {
+		  "mission": [
+			{
+			  "id": "Mission1",
+			  "crew": [
+				{
+				  "id": "Astronaut1",
+				  "missions": [
+					{
+					  "id": "Mission1"
+					}
+				  ]
+				}
+			  ]
+			}
+		  ]
+		}
+	  }`
+	testutil.CompareJSON(t, expectedJSON, string(gqlResponse.Data))
+
+	varMap2 := map[string]interface{}{
+		"missionId":   "Mission2",
+		"astronautId": "Astronaut1",
+		"des":         "Apollo2",
+	}
+	addMissionParams.Variables = varMap2
+
+	gqlResponse1 := addMissionParams.ExecuteAsPost(t, GraphqlURL)
+	RequireNoGQLErrors(t, gqlResponse)
+
+	expectedJSON = `{
+		"addMission": {
+		  "mission": [
+			{
+			  "id": "Mission2",
+			  "crew": [
+				{
+				  "id": "Astronaut1",
+				  "missions": [
+					{
+					  "id": "Mission1"
+					},
+					{
+					  "id": "Mission2"
+					}
+				  ]
+				}
+			  ]
+			}
+		  ]
+		}
+	  }`
+	testutil.CompareJSON(t, expectedJSON, string(gqlResponse1.Data))
+
+	astronautDeleteFilter := map[string]interface{}{"id": []string{"Astronaut1"}}
+	DeleteGqlType(t, "Astronaut", astronautDeleteFilter, 1, nil)
+
+	missionDeleteFilter := map[string]interface{}{"id": map[string]interface{}{"in": []string{"Mission1", "Mission2"}}}
+	DeleteGqlType(t, "Mission", missionDeleteFilter, 2, nil)
+}
+
+func addMutationOnExtendedTypeWithIDasKeyField(t *testing.T) {
+	addAstronautParams := &GraphQLParams{
+		Query: `mutation addAstronaut($id1: ID!, $missionId1: String!, $id2: ID!, $missionId2: String! ) {
+			addAstronaut(input: [{id: $id1, missions: [{id: $missionId1, designation: "Apollo1"}]}, {id: $id2, missions: [{id: $missionId2, designation: "Apollo2"}]}]) {
+				astronaut(order: {asc: id}){
+					id
+					missions {
+						id
+						designation
+					}
+				}
+			}
+		}`,
+		Variables: map[string]interface{}{
+			"id1":        "Astronaut1",
+			"missionId1": "Mission1",
+			"id2":        "Astronaut2",
+			"missionId2": "Mission2",
+		},
+	}
+
+	gqlResponse := addAstronautParams.ExecuteAsPost(t, GraphqlURL)
+	RequireNoGQLErrors(t, gqlResponse)
+
+	expectedJSON := `{
+		"addAstronaut": {
+		  "astronaut": [
+			{
+			  "id": "Astronaut1",
+			  "missions": [
+				{
+				  "id": "Mission1",
+				  "designation": "Apollo1"
+				}
+			  ]
+			},
+			{
+			  "id": "Astronaut2",
+			  "missions": [
+				{
+				  "id": "Mission2",
+				  "designation": "Apollo2"
+				}
+			  ]
+			}
+		  ]
+		}
+	  }`
+
+	testutil.CompareJSON(t, expectedJSON, string(gqlResponse.Data))
+
+	astronautDeleteFilter := map[string]interface{}{"id": []string{"Astronaut1", "Astronaut2"}}
+	DeleteGqlType(t, "Astronaut", astronautDeleteFilter, 2, nil)
+
+	missionDeleteFilter := map[string]interface{}{"id": map[string]interface{}{"in": []string{"Mission1", "Mission2"}}}
+	DeleteGqlType(t, "Mission", missionDeleteFilter, 2, nil)
+}

graphql/e2e/common/query.go

@@ -19,7 +19,6 @@ package common
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/spf13/cast"
 	"io/ioutil"
 	"math/rand"
 	"net/http"
@@ -29,6 +28,8 @@ import (
 	"testing"
 	"time"
 
+	"github.com/spf13/cast"
+
 	"github.com/google/go-cmp/cmp/cmpopts"
 
 	"github.com/dgraph-io/dgraph/graphql/schema"
@@ -374,6 +375,71 @@ func allPosts(t *testing.T) []*post {
 	return result.QueryPost
 }
 
+func entitiesQuery(t *testing.T) {
+	addSpaceShipParams := &GraphQLParams{
+		Query: `mutation addSpaceShip($id1: String!, $missionId1: String! ) {
+			addSpaceShip(input: [{id: $id1, missions: [{id: $missionId1, designation: "Apollo1"}]} ]) {
+				spaceShip {
+					id
+					missions {
+						id
+						designation
+					}
+				}
+			}
+		}`,
+		Variables: map[string]interface{}{
+			"id1":        "SpaceShip1",
+			"missionId1": "Mission1",
+		},
+	}
+
+	gqlResponse := addSpaceShipParams.ExecuteAsPost(t, GraphqlURL)
+	RequireNoGQLErrors(t, gqlResponse)
+
+	entitiesQueryParams := &GraphQLParams{
+		Query: `query _entities($typeName: String!, $id1: String!){
+			_entities(representations: [{__typename: $typeName, id: $id1}]) {
+				... on SpaceShip {
+					missions(order: {asc: id}){
+						id
+						designation
+					}
+				}
+			}
+		}`,
+		Variables: map[string]interface{}{
+			"typeName": "SpaceShip",
+			"id1":      "SpaceShip1",
+		},
+	}
+
+	entitiesResp := entitiesQueryParams.ExecuteAsPost(t, GraphqlURL)
+	RequireNoGQLErrors(t, entitiesResp)
+
+	expectedJSON := `{
+		"_entities": [
+		  {
+			"missions": [
+			  {
+				"id": "Mission1",
+				"designation": "Apollo1"
+			  }
+			]
+		  }
+		]
+	  }`
+
+	testutil.CompareJSON(t, expectedJSON, string(entitiesResp.Data))
+
+	spaceShipDeleteFilter := map[string]interface{}{"id": map[string]interface{}{"in": []string{"SpaceShip1"}}}
+	DeleteGqlType(t, "SpaceShip", spaceShipDeleteFilter, 1, nil)
+
+	missionDeleteFilter := map[string]interface{}{"id": map[string]interface{}{"in": []string{"Mission1"}}}
+	DeleteGqlType(t, "Mission", missionDeleteFilter, 1, nil)
+
+}
+
 func inFilterOnString(t *testing.T) {
 	addStateParams := &GraphQLParams{
 		Query: `mutation addState($name1: String!, $code1: String!, $name2: String!, $code2: String! ) {