Can type merging and gateway schema extension coexists?

[MirkoGibin]

Hi everyone.

If I try to add a resolver to the stitching configuration, type merging does not work for the result of the resolver.

I have a book schema and a library schema. Stitching among them works fine: if I call allLibraries or allBooks queries I can easily navigate through the graph.

Lets say I want to hide to client all subschemas queries and expose only the query exposedQuery defined here in the stitching configuration (maybe a dumb example, but it was the simplest one I could think of). The exposedQuery resolver then uses delegateToSchema to "redirect" the query to the right subschema.

I can compose a valid query with exposedQuery that let me navigate through the graph but, when I execute it, it fails with
Cannot return null for non-nullable field Library.books.

Since the query is valid against the schema I was expecting I could be able to resolve all fields using the type merging configurations.

Why stitching is not working with the exposedQuery resolver? Am I misusing something?

CodeSanbox Example

To Reproduce

Gateway implementation

import express from 'express'
import {createYoga} from 'graphql-yoga';
import {filterSchema, pruneSchema} from '@graphql-tools/utils';
import {stitchSchemas} from '@graphql-tools/stitch';
import {delegateToSchema, SubschemaConfig} from '@graphql-tools/delegate';
import {makeExecutableSchema} from '@graphql-tools/schema';
import {OperationTypeNode} from 'graphql/language';
import {graphql} from 'graphql';

class Library {
   id: string
   name: string
}

class Book {
   id: string
   title: string
   libraryId: string
}

const libraries: Library[] = [
   {
       id: "1",
       name: "library1"
   },
   {
       id: "2",
       name: "library2"
   },
   {
       id: "3",
       name: "library3"
   }
]

const books: Book[] = [
   {
       id: "1",
       title: "book1",
       libraryId: "1",
   },
   {
       id: "2",
       title: "book2",
       libraryId: "1",
   },
   {
       id: "3",
       title: "book3",
       libraryId: "2",
   }
]


const libraryService: SubschemaConfig = {
   schema: makeExecutableSchema({
       typeDefs: `
type Library {
   id: ID!
   name: String
}

type Book {
   library: Library!
}

type Query {
   allLibraries: [Library!]!
   _library(libraryIds: [ID!]!): [Book!]!
}
       `,
       resolvers: {
           Query: {
               allLibraries: (originalObject, args, context, info): Library[] => {
                   return libraries
               },
               _library: (originalObject, args, context, info) => {
                   const result = []
                   args.libraryIds.forEach(libraryId => {

                       libraries.filter(l => l.id == libraryId).map(l => {
                           return {
                               library: l
                           }
                       }).forEach(r => result.push(r))
                   })
                   return result
               }
           }
       },
   }),
   merge: {
       Book: {
           selectionSet: '{ libraryId }',
           fieldName: '_library',
           key: ({libraryId}) => libraryId,
           argsFromKeys: (libraryIds) => ({libraryIds}),
       }
   },
   batch: true,
}

const bookService: SubschemaConfig = {
   schema: makeExecutableSchema({
       typeDefs: `
type Book {
   id: ID!
   title: String
   libraryId: ID!
}

type Library {
   id: ID!
   books: [Book!]!
}

type Query {
   allBooks: [Book!]!
   _booksByLibrary(libraryIds: [ID!]!): [Library!]!
}
       `,
       resolvers: {
           Query: {
               allBooks: (source, args, context, info): Book[] => {
                   return books
               },
               _booksByLibrary: (source, args, context, info) => {
                   const result = []
                   args.libraryIds.forEach(libraryId => {
                       const tempLibrary = {
                           id: libraryId,
                           books: [],
                       }

                       books.filter(book => book.libraryId == libraryId).forEach(book => tempLibrary.books.push(book))

                       result.push(tempLibrary)
                   })
                   return result
               }
           }
       },
   }),
   merge: {
       Library: {
           selectionSet: '{ id }',
           fieldName: '_booksByLibrary',
           key: ({id}) => id,
           argsFromKeys: (libraryIds) => ({libraryIds}),
       }
   },
   batch: true,

}

const gatewaySchema = pruneSchema(
   filterSchema(
       {
           schema: stitchSchemas({
               subschemas: [libraryService, bookService],
               typeDefs: `
                   type Query {
                       exposedQuery: [Library!]!
                   }
               `,
               resolvers: {
                   Query: {
                       exposedQuery: async (source, args, context, info) => {
                           return await delegateToSchema({
                               schema: libraryService,
                               operation: OperationTypeNode.QUERY,
                               fieldName: 'allLibraries',
                               context: context,
                               info: info,
                           })
                       }
                   }
               }
           }),

           rootFieldFilter: (type, fieldName) => !fieldName.startsWith('_'),
       }
   )
)

// setup of the yoga server that will support our gateway
const yogaServer = createYoga({
   schema: gatewaySchema,
   batching: true,
})

// app bootstrap and start
const app = express()


// Disclosing fingerprints from web application technologies is security-sensitive.
app.disable("x-powered-by");

const path = "/graphql"
const port = "8082"

app.post(path, yogaServer)
const server = app.listen(port, () =>
   console.log("gateway running. Port " + port + ", path " + path))

// stitching is working, everything is ok
graphql({
   schema: gatewaySchema,
   source: `
           query AllBooks {
               allBooks {
                   library {
                       id
                       name
                       books {
                           id
                           title
                           libraryId
                           library {
                               id
                               name
                           }
                       }
                   }
               }
           }
   `
}).then(value => {
   console.log(value)
}).catch(reason => console.log(reason))

// stitching is working, everything is ok
graphql({
   schema: gatewaySchema,
   source: `
       query AllLibraries {
           allLibraries {
               id
               name
               books {
                   id
                   title
                   libraryId
                   library {
                       id
                       name
                   }
               }
           }
       }
   `
}).then(value => {
   console.log(value)
}).catch(reason => console.log(reason))

// stitching is NOT working and I receive the error  Cannot return null for non-nullable field Library.books
graphql({
   schema: gatewaySchema,
   source: `
       query ExposedQuery {
           exposedQuery {
               id
               name
               books {
                   id
                   title
                   libraryId
               }
           }
       }
   `
}).then(value => {
   console.log(value)
}).catch(reason => console.log(reason))

Dependencies

"dependencies": {
  "@graphql-tools/stitch": "9.0.5",
 "@graphql-tools/schema": "10.0.3",
 "@graphql-tools/delegate": "10.0.4",
 "@graphql-tools/utils": "10.1.2",
 "express": "4.19.2",
 "graphql": "16.8.1",
 "graphql-yoga": "5.3.0"
}