Define an object in graphql schema language and export it as GraphQLObjectType

[jmesimak]

Hello, we have recently migrated away from express-graphql to Apollo Server. Currently our schema is built like so:

// Image.js
export default new GraphQLObjectType({
  name: 'Image',
  fields: {
    id: { type: GraphQLString, resolve: (block) => {...} },
    alt: { type: GraphQLString, resolve: (block) => {...} }
  }
})

// Media.js
import Image from './Image'
const Media = new GraphQLObjectType({
  name: 'Media',
  fields: {
    image: { type: Image },
    video: { type: Video }
  }
})

I would like to gradually move to graphql schema language, preferably starting by declaring "leaf nodes" such as Image with it first. So in a nutshell, I would like to write this:

const typedefs = `#graphql
  type Image {
    id: String
    alt: String
  }
`

const resolvers = { ... }

export default schemaToGraphqlObject(typedefs, resolvers)

Any help is appreciated, thanks!

[trevor-scheer]

It looks like the mergeSchemas function from @graphql-tools/schema accomplishes what you're after?
https://the-guild.dev/graphql/tools/docs/schema-merging

[jmesimak]

Thanks! This is exactly it.

For anyone in the future: you probably have something like const oldSchema = new GraphQLSchema... as your root schema. You can use that with mergeSchemas like so:

const schema = mergeSchemas({
  schemas: [oldSchema],
  typeDefs: `new typedefs go here`,
  resolvers: {} // corresponding new resolvers here
})

Anything in the typeDefs and resolvers will overwrite whatever you had in your oldSchema so you can leave the old declarations dangling until they are not referenced any more. They can even be "dummies" with all old fields removed since the later typeDefs declaration will overwrite the old stuff. I did it like this:

// Replaced by new schema language definitions
export const Layout = new GraphQLObjectType({
  name: 'Layout',
  fields: { deprecated: { type: GraphQLBoolean } }
})

Also observe the functions mergeTypeDefs and mergeResolvers, helpful when wrangling a larger codebase together so that you don't end up with a humongous template string in your typeDefs.