如何实现 isTypeOf 方法? [英] How to implement isTypeOf method?
问题描述
鉴于此架构:
interface INode {身份证:身份证}类型 Todo 实现 INode {身份证:身份证标题:字符串!}类型查询{节点(ID:ID!):INode}
给定这个类:
导出默认类 Todo {构造函数(公共 ID:字符串,公共标题:字符串){ }isTypeOf(value: any): Boolean {返回值 instanceof Todo;}}
给定这个解析器:
type NodeArgs = {id:字符串}导出常量解析器 = {节点:({ id }:NodeArgs)=>{return new Todo('1', 'Todo 1');}}
当我调用查询时:
查询{节点(ID:1"){ID... 在 Todo {标题}}}
然后我得到以下回报:
<代码>{错误":[{"message": "抽象类型 INode 必须在运行时解析为字段 Query.node 的对象类型,其值为 { id: "1", title: "Todo 1" }, received "undefined".要么INode 类型应该提供一个 "resolveType" 函数或者每个可能的类型应该提供一个 "isTypeOf" 函数.",地点":[{线":2,列":3}],小路": [节点"]}],数据": {节点":空}}
如您所见,我已经实现了 isTypeOf
函数,但仍然收到错误消息.
我做错了什么?
注意事项:
- 我正在使用 Typescript、express 和 express-graphql;
isTypeOf
是以编程方式创建架构时传递给 GraphQLObjectType 构造函数的函数.resolveType
函数和联合/接口也是如此.如果您使用 SDL 并使用 buildSchema
创建架构,则无法将这些函数注入到您创建的架构中,就像您无法为 buildSchema
以外的类型的字段提供解析器一样code>Query 和 Mutation
.
您有几个选择.一种选择是利用默认的 resolveType
行为.这会检查对象上的 __typename
属性,然后回退到在每个实现类型上调用 isTypeOf
直到匹配为止.这意味着如果您使用的是类,那么执行以下操作就足够了:
导出默认类 Todo {得到 __typename() {返回待办事项"}}
更好的选择是删除 buildSchema
并使用 graphql-tools
中的 makeExecutableSchema
.然后您可以直接在解析器中定义 resolveType
和/或 isTypeOf
函数.例如:
const 解析器 = {询问: {节点:(对象,参数,上下文,信息)=>{return new Todo('1', 'Todo 1')}},节点:{__resolveType: (obj, context, info) =>{if (obj instanceof Todo) 返回 'Todo'},}}
您不仅可以通过这种方式轻松定义 isTypeOf
或 resolveType
,还可以轻松地为任何类型的字段添加解析器,并轻松添加自定义标量.如果您仅使用 buildSchema
,则无法(轻松)执行任何操作.
如果你更喜欢使用 isTypeOf
而不是 resolveType
,解析器看起来像这样:
const 解析器 = {询问: {节点:(对象,参数,上下文,信息)=>{return new Todo('1', 'Todo 1')}},去做: {__isTypeOf: (obj, context, info) =>{返回 obj 实例的 Todo},}}
只需要其中一个.要么为您使用的每个抽象类型编写一个 resolveType
函数,或为每个可能是抽象类型的对象类型编写一个 isTypeOf
.>
Given this schema:
interface INode {
id: ID
}
type Todo implements INode {
id: ID
title: String!
}
type Query {
node(id: ID!): INode
}
Given this class:
export default class Todo {
constructor (public id: string, public title: string) { }
isTypeOf(value: any): Boolean {
return value instanceof Todo;
}
}
Given this resolver:
type NodeArgs = {
id: string
}
export const resolver = {
node: ({ id }: NodeArgs) => {
return new Todo('1', 'Todo 1');
}
}
When I call the query:
query {
node(id: "1") {
id
... on Todo {
title
}
}
}
Then I get the return below:
{
"errors": [
{
"message": "Abstract type INode must resolve to an Object type at runtime for field Query.node with value { id: "1", title: "Todo 1" }, received "undefined". Either the INode type should provide a "resolveType" function or each possible type should provide an "isTypeOf" function.",
"locations": [
{
"line": 2,
"column": 3
}
],
"path": [
"node"
]
}
],
"data": {
"node": null
}
}
As you can see, I've implemented the isTypeOf
function but I am still getting the error message.
What am I doing wrong?
Notes:
- I am using Typescript, express and express-graphql;
isTypeOf
is a function that is passed to the constructor of a GraphQLObjectType when you create your schema programatically. Ditto for resolveType
functions and unions/interfaces. If you use SDL and create your schema using buildSchema
, there is no way to inject those functions into your created schema, just like you don't have a way to provide resolvers for fields on types other than Query
and Mutation
.
You have a couple of options. One option is to utilize the default resolveType
behavior. This checks for a __typename
property on the object, and falls back to calling isTypeOf
on every implementing type until it matches. That means if you're using a class, it should be sufficient to do something like this:
export default class Todo {
get __typename() {
return 'Todo'
}
}
The better option would be to drop buildSchema
and use makeExecutableSchema
from graphql-tools
. Then you can define your resolveType
and/or isTypeOf
functions directly in your resolvers. For example:
const resolvers = {
Query: {
node: (obj, args, context, info) => {
return new Todo('1', 'Todo 1')
}
},
INode: {
__resolveType: (obj, context, info) => {
if (obj instanceof Todo) return 'Todo'
},
}
}
Not only can you easily define isTypeOf
or resolveType
this way, you can also easily add resolvers for fields of any type and add custom scalars without any hassle. You cannot do any of that (easily) if you're using just buildSchema
.
Edit:
If you prefer to utilize isTypeOf
instead of resolveType
, the resolvers would look something like this:
const resolvers = {
Query: {
node: (obj, args, context, info) => {
return new Todo('1', 'Todo 1')
}
},
Todo: {
__isTypeOf: (obj, context, info) => {
return obj instanceof Todo
},
}
}
Only one or the other is necessary. Either write a resolveType
function for every abstract type you use, or write a isTypeOf
for every object type that could be an abstract type.
这篇关于如何实现 isTypeOf 方法?的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!