Type extension does not work

[pie6k]

Assume

main.graphql

# import * from "./User.graphql"
type Query {
  apiVersion: String!
}

User.graphql

type User {
  name: String!
}
extend type Query {
  me: User!
}

In resulting compiled schema Query has only version. There is no me field added.

[kbrandwijk]

This is a limitation coming from graphql: graphql/graphql-js#922. I believe that extend definitions should be taken into consideration, but there has not been any recent activity on actually making that happen.

[huv1k]

I would like it too, it could be great feature 👍

[marktani]

A similar but different use case is extending imported types (like User) by a field:

# import * from "./User.graphql"
extend type User {
  extraField: String!
}

Does this work?

[kbrandwijk]

No that's the same situation. The extend definition is simply ignored by graphql when we read in the schema. This is something that needs to be implemented by graphql-js first. We use parse() from graphql to read in the schema.

[schickling]

@IvanGoncharov any idea when this functionality will land?

[pie6k]

Good use case of this could be having many files in project extending query and mutation type as it would lead to well organized, modular files structure.

[mwoelk]

Right now we can simulate the behavior at least for Query-, Mutation- and Subscription-Type by importing like:

# import Query.* from a.graphql
# import Query.* from b.graphql

Take a look at the following test cases:

• Merged root field
• Empty root schema with only imports

[IvanGoncharov]

@IvanGoncharov any idea when this functionality will land?

@schickling As always then somebody implements it 😄
Note: graphql/graphql-js#1199 introduce a big change in how extend works so it's better to wait until it either merged or rejected.

[divyenduz]

Another use case for this would be to extend and add "future" stuff (say, that Prisma is yet to implement like https://github.com/graphcool/prisma/issues/60).

Currently, I am copying the original type from prisma.graphql and adding "future" fields to it but this will make that chunk of code more beautiful 👍

[mjdickinson]

I need this too. I have managed to work around by just loading .graphql files myself and passing an array of strings to makeExecutableSchema() (and using extend type Query etc. to avoid multiple declaration errors). graphql-tools and graphql seem to handle the type extensions fine.

[ACollectionOfAtoms]

I got around this in the following way (though it may be a pain to refactor once extend is fixed up):

in A.graphql

type A {
    name: String!
}

type Query { # notice all we have to do is omit 'extend'
   AbyName(name: String!): A
}

in schema.graphql

# import * from 'A.graphql'
# and import the whole thing as above

type Query {
   someRootQuery(thing: String!): A
}

So this way each file can be modular in that they will contain all their own Querys and Mutations etc.

[Grmiade]

Any news about extend compatibility in this package?

...
import { importSchema } from 'graphql-import'

const server = new GraphQLServer({
    context,
    resolvers: {
      Employee: {
        test: () => 'okok',
      },
      Query: {
        employee: (_root, args, context, info) => {
          return context.myBinding.query.employee(args, info)
        },
      },
    },
    typeDefs: [importSchema('./src/schema.graphql'), `extend type Employee { test: String }`],
  })

If I use extend feature outside the graphql-import scope, it works

[james-ff]

I think @Grmiade has correctly identified the issue in the last comment. In my use case I am following guides on merging schemas https://www.apollographql.com/docs/graphql-tools/schema-stitching.html. This requires a typeDefs definition that only contains 'extend type' blocks to effectively bridge two schemas.

const linkTypeDefs = `extend type FirstSchemaEntity { test: SecondSchemaEntity }`

When used in literal form as in the above comment it works. But it doesn't work and errors when the extend typeDefs definition is imported via importSchema, in the below example.

const linkTypeDefs = importSchema('./linkTypeDefs.graphql')