GraphQLServer 联合类型“抽象类型 N 必须在运行时解析为对象类型”错误

Question

Given a GraphQL union return type:

union GetBankAccountsResponseOrUserInputRequest = GetAccountsResponse | UserInputRequest

meant to be returned by a given resolver:

type Query {
  getBankAccounts: GetBankAccountsResponseOrUserInputRequest!
}

I'm getting these warnings or errors regarding a __resolveType or __isTypeOf function:

Abstract type N must resolve to an Object type at runtime for field Query.getBankAccounts with value { ..., __isTypeOf: [function __isTypeOf] }, received "undefined". Either the N type should provide a "resolveType" function or each possible type should provide an "isTypeOf" function.'

I've searched for days in github issues and SO questions looking to resolve this error.

Implementing __resolveType or __isTypeOf in my resolvers is not working:

export const Query = {
  getBankAccounts: (parent, args, context: IContext, info) => {
    return {
      __isTypeOf(obj) { // OR __resolveType, none of them work
        return `GetAccountsResponse`;
      },
      accounts: []
    };
  },
};

Answer 1

Since implementing __resolveType or __isTypeOf in my resolvers didn't work for me, I ended up solving this issue by adding the __typename directly into the resolver return Object.

In the getBankAccounts resolver implementation:

async getBankAccounts(): GetBankAccountsResponseOrUserInputRequest {
    if (shouldGetUserInputRequest()) {
      return {
        __typename: "UserInputRequest",
        ...response,
      };
    }

    return {
      __typename: "GetAccountsResponse",
      accounts,
    };
  }

Hope that this helps somebody.

Answer 2

Your resolver map is not set up correctly.

The resolver map passed to ApolloServer (or makeExecutableSchema ) should should be an object whose keys are type names in your schema, with each key mapping to another object whose keys are field names on that type. Each field name then maps to a resolver function.

const resolvers = {
  SomeType: {
    someField: (parent, args, context, info) => { ... },
  },
}

You use the same resolver map to pass in the resolveType function for a union or interface. The pattern is the same, but the name of the type is the name of the union or interface and instead of a field name, the key is __resolveType :

const resolvers = {
  SomeType: {
    someField: (parent, args, context, info) => { ... },
  },
  SomeUnion: {
    __resolveType: (parent) => { ... },
  }
}

The resolveType function should always return a string that matches the name of an existing object type in your schema.

If you use __isTypeOf instead of __resolveType , then this will look a bit different because the isTypeOf function is associated with a particular object type, not the interface or union. This is all shown in the docs . So the resolver map looks like this:

const resolvers = {
  SomeType: {
    someField: (parent, args, context, info) => { ... },
    __isTypeOf: (parent) => { ... },
  },
}

__isTypeOf should always return either true or false , depending on whether the passed in object is in fact that type.

You only need to use either __resolveType or __isTypeOf . If you use __isTypeOf , you have to add it to every possible object type in the union or interface.