Javascript GraphQL:提供的用于构建架构的类型之一缺少名称

我正在学习GraphQL，所以我遇到了一个奇怪的问题

我在一个文件Schema.js中有以下代码：

const graphQL = require('graphql');
const lodash = require('lodash')
const { GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLID, GraphQLSchema, GraphQLList } = graphQL;

const StatusType = new GraphQLObjectType({
name: 'Status',
fields: () => ({
    id: { type: GraphQLInt },
    statusName: { type: GraphQLString },
    user: {
        type: new GraphQLList(UserType),
        resolve(parentValue, args){
            
        }
    }
})
});

const UserType = new GraphQLObjectType({
name: 'User',
fields: () => ({
    id: { type: GraphQLString },
    username: { type: GraphQLString },
    mail: { type: GraphQLString },
    password: { type: GraphQLString },
    status: { 
        type: StatusType,
        resolve(parentValue, args){
            
        }
    },
})
});

const RouteQuery = new GraphQLObjectType({
name: 'RouteQuery',
user: {
        type: UserType,
        args: { id: { type: GraphQLString } },
        resolve(parentValue, args){
            //return lodash.find(users, { id: args.id })
        }
    },
userSome: {
        type: new GraphQLList(UserType),
        args: { id: { type: GraphQLString } },
        resolve(parentValue, args){
            if (args.id) {
                //return users.filter(user => user.id === args.id);
            }
            //return users;
        }
    },
userAll: {
        type: new GraphQLList(UserType),
        resolve(parentValue){
            //return users
        }
    },
status:{
        type: StatusType,
        args: { id: { type: GraphQLInt } },
        resolve(parentValue, args){
            //return lodash.find(status, { id: args.id })
        }
    },
statusAll: {
        type: new GraphQLList(StatusType),
        resolve(parentValue){
            //return users
        }
    }
    }
});

module.exports = new GraphQLSchema({
query: RouteQuery
})

此代码成功运行，但当我尝试将它们分离到多个文件时：

const StatusType&UserType

如下所示： StatusType位于StatusType.js文件中，UserType位于UserType.js文件中

StatuType.js文件：

const graphQL = require('graphql');
const { GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLID, GraphQLSchema, GraphQLList } = graphQL;
const UserType = require('./UserType')
const StatusType = new GraphQLObjectType({
name: 'Status',
fields: () => ({
    id: { type: GraphQLInt },
    statusName: { type: GraphQLString },
    user: {
        type: new GraphQLList(UserType),
        resolve(parentValue, args){
            //return users.filter(user => user.status === parentValue.id);
        }
    }
})
});
module.exports = StatusType;

const graphQL = require('graphql');
const { GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLID, GraphQLSchema, GraphQLList } = graphQL;
const StatusType = require('./StatusType')

const UserType = new GraphQLObjectType({
name: 'User',
fields: () => ({
    id: { type: GraphQLString },
    username: { type: GraphQLString },
    mail: { type: GraphQLString },
    password: { type: GraphQLString },
    status: { 
        type: StatusType,
        resolve(parentValue, args){
            //return lodash.find(status, { id: parentValue.status })
        }
    },
})
});
module.exports = UserType;

UserType.js文件：

const graphQL = require('graphql');
const { GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLID, GraphQLSchema, GraphQLList } = graphQL;
const UserType = require('./UserType')
const StatusType = new GraphQLObjectType({
name: 'Status',
fields: () => ({
    id: { type: GraphQLInt },
    statusName: { type: GraphQLString },
    user: {
        type: new GraphQLList(UserType),
        resolve(parentValue, args){
            //return users.filter(user => user.status === parentValue.id);
        }
    }
})
});
module.exports = StatusType;

const graphQL = require('graphql');
const { GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLID, GraphQLSchema, GraphQLList } = graphQL;
const StatusType = require('./StatusType')

const UserType = new GraphQLObjectType({
name: 'User',
fields: () => ({
    id: { type: GraphQLString },
    username: { type: GraphQLString },
    mail: { type: GraphQLString },
    password: { type: GraphQLString },
    status: { 
        type: StatusType,
        resolve(parentValue, args){
            //return lodash.find(status, { id: parentValue.status })
        }
    },
})
});
module.exports = UserType;

在Schema.js文件中，我包括以下两个：

const StatusType = require('./StatusType');
const UserType = require('./UserType');

因此，我没有将所有代码放在同一个文件中，而是将StatusType和UserType放在各自的文件中

但当我运行此代码时，我得到了以下错误：

所以我不知道这里的问题是什么：/

---

但是当我尝试console.log时，

const UserType=require（'./UserType'）

我得到了

User

作为响应：o就像它在Schema.js上的同一个代码上一样

您在声明之前导入了StatusType中的UserType

const StatusType = require('./StatusType');
const UserType = require('./UserType');

---

nodeJs处理

require

的方式存在问题。有关如何在节点中处理

require

，请参阅

特别是在您的情况下，当您：

const StatusType=require（'./StatusType'）；
const UserType=require（'./UserType'）；

StatusType

从

const StatusType=require（'./StatusType'）加载

StatusType.js从

const UserType=require（'./UserType'）

UserType.js应该要求

StatusType

，但NodeJ会阻止这一点，以避免无限循环。因此，它将执行下一行

UserType

初始化为

new-GraphQLObjectType（…）

并将

字段定义为函数。函数闭包包含一个尚未初始化的变量
StatusType
。它只是一个空的导出模块
{}

您可以验证添加

console.log（StatusType）创建
UserType
字段时：

const UserType=new-GraphQLObjectType({
名称：“用户”，
字段：（）=>{
console.log（StatusType）；
返回({
id:{type:GraphQLString}，
用户名：{type:GraphQLString}，
邮件：{type:GraphQLString}，
密码：{type:GraphQLString}，
地位：{
类型：StatusType，
解析（parentValue，args）{
}
},
});
}
});

您将获得：

{}//而不是StatusType

当所有内容都在同一个文件中时，您没有遇到此问题，因为
UserType
和
StatusType
都是在同一个闭包中定义的，现在它们彼此都定义了

要解决这个问题，您必须在同一级别上定义
UserType
和
StatusType
，并将它们注入。我们可以找到一个很好的例子来说明如何做到这一点。就你而言：

//StatusType.js
const StatusType=（types）=>new GraphQLObjectType({
名称：'状态'，
字段：（）=>{
console.log（types.UserType）；
返回({
id:{type:GraphQLInt}，
状态名称：{type:GraphQLString}，
用户：{
类型：新的GraphQList（types.UserType），
解析（parentValue，args）{
}
}
});
}
});
module.exports=状态类型；
//UserType.js
const UserType=（types）=>new GraphQLObjectType({
名称：“用户”，
字段：（）=>{
console.log（type.StatusType）；
返回({
id:{type:GraphQLString}，
用户名：{type:GraphQLString}，
邮件：{type:GraphQLString}，
密码：{type:GraphQLString}，
地位：{
类型：types.StatusType，
解析（parentValue，args）{
}
},
});
}
});
module.exports=用户类型；
//Schema.js
const StatusTypeInject=require（'./StatusType'）；
const UserTypeInject=require（'./UserType'）；
常量类型={}；
types.StatusType=StatusTypeInject（类型）；
types.UserType=UserTypeInject（类型）；
const StatusType=types.StatusType；
const UserType=types.UserType；
您可以在这里进行一些清理，下面是我解决这些问题的方法：

[…]
//从graphql库导入GraphQLNonNull
//在您的情况下，我会使用GraphQLID而不是GraphQLString
用户群：{
类型：新的GraphQList（require（'../path/to/UserType'）），
args:{id:{type:new-GraphQLNonNull（GraphQLID）}，
解析：异步（parentValue，args）=>{
//不需要if语句，因为我们肯定有一个id。
//按id返回等待筛选用户。
}
},
[..]

和往常一样，将
字段作为函数：
字段：（）=>（{}）