错误：预期 [object Object] 是 GraphQL 类型

Question

在我将资源部分添加到代码中之前，此代码一直有效。它与其他两个相似，所以我不确定为什么它不起作用。

提前致谢

更新：- 使用调试器后，我开始明白问题出在 RootQueryType.js 和与之关联的文件中，因为当我尝试导出架构并且恰好在 query:RootQueryType 位置但仍然无法查明时弹出错误在错误处。

更新：- 我也把 schema.js 文件放在最后了

resourceType.js

const graphql = require("graphql");
const UserType = require("./userType");
const User = require("../models/User");
const Project = require("../models/Project");
const Resource = require("../models/Resource");
const ProjectType = require("./projectType");

const {
    GraphQLObjectType,
    GraphQLString,
    GraphQLList,
  } = graphql;


  const ResourceType = new GraphQLObjectType({
    name: "ResourceType",
    fields: () => ({
      id: { type: GraphQLString },
      title: { type: GraphQLString },
      url: { type: GraphQLString },
      project:{
        type:ProjectType,
        resolve(parentValues,args){
          return Project.findById(parentValues.id).populate("resources")
        }
      }
    })
  });

  module.exports=ResourceType;

RootQueryType.js

    const mongoose = require('mongoose');
const graphql = require('graphql');
const { GraphQLObjectType, GraphQLList, GraphQLID, GraphQLNonNull } = graphql;

const ProjectType  = require('./../types/projectType');
const UserType  = require('./../types/userType');
const Project=require("../models/Project");
const User=require("../models/User");

 const RootQuery=new GraphQLObjectType({
    name:"RootQueryType",
    fields: () => ({
        projects:{
            type:new GraphQLList(ProjectType),
            resolve(parentValues,args,request){
                return Project.find().populate("contributors").populate("resources");
            }
        },
        project:{
            type:ProjectType,
            args:{id:{type:new GraphQLNonNull(GraphQLID)}},
            resolve(parentValue,args,request){
                return Project.findById(args.id).populate("contributors").populate("resources");
            }
        },
        users:{
            type:new GraphQLList(UserType),
            resolve(parentValues,args,request){
                return User.find().populate("projects");
            }
        },
        user:{
            type:UserType,
            args:{id:{type:new GraphQLNonNull(GraphQLID)}},
            resolve(parentValue,args,request){
                return User.findById(args.id).populate("projects")
            }
        },

    })
})

module.exports = RootQuery;

变异.js

    const mongoose = require("mongoose");
const ProjectType = require("./../types/projectType");
const UserType = require("./../types/userType");
const graphql = require("graphql");
const {
  GraphQLObjectType,
  GraphQLList,
  GraphQLID,
  GraphQLNonNull,
  GraphQLString
} = graphql;

const Project = require("../models/Project");
const User = require("../models/User");

const mutation = new GraphQLObjectType({
  name: "mutation",
  fields: () => ({
    addUser: {
      type: UserType,
      args: {
        name: { type: new GraphQLNonNull(GraphQLString) },
        username: { type: new GraphQLNonNull(GraphQLString) },
        password: { type: new GraphQLNonNull(GraphQLString) },
        email: { type: new GraphQLNonNull(GraphQLString) },
        githubProfile: { type: new GraphQLNonNull(GraphQLString) }
      },
      resolve(parentValues, args, request) {
        return User.create(args);
      }
    },
    addProject: {
      type: ProjectType,
      args: {
        name: { type: new GraphQLNonNull(GraphQLString) },
        description: { type: new GraphQLNonNull(GraphQLString) },
        image: { type:GraphQLString },
        // contributor:{ type: new GraphQLNonNull(new GraphQLList(GraphQLID))
        contributor:{ type: new GraphQLNonNull(GraphQLID)
         },
      },
      resolve(parentValues, args, request) {
        return Project.create(args);
      }
    }
  })
});

module.exports = mutation;

我很肯定这不是其他类型的问题，因为它们工作得更早，我只将 .populate("resources") 属性添加到它们的解析函数中。但以防万一我也为他们添加代码。

userType.js

const graphql = require("graphql");
const ProjectType = require("./projectType");

const { GraphQLObjectType, GraphQLString, GraphQLList } = graphql;

const UserType = new GraphQLObjectType({
  name: "User",
  fields: () => ({
    id: { type: GraphQLString },
    name: { type: GraphQLString },
    githubProfile: { type: GraphQLString },
    username: { type: GraphQLString },
    password: { type: GraphQLString },
    email: { type: GraphQLString },
    projects: {
      type: new GraphQLList(ProjectType),
      resolve(parentValues, args) {
        return User.findById(parentValues.id).populate("projects");
      }
    }
  })
});

module.exports = UserType;

另一个是

projectType.js

const graphql = require("graphql");
const UserType = require("./userType");
const ResourceType = require("./resourceType");
const User = require("../models/User");
const Project = require("../models/Project");

const {
  GraphQLObjectType,
  GraphQLString,
  GraphQLList,
} = graphql;

const ProjectType = new GraphQLObjectType({
  name: "ProjectType",
  fields: () => ({
    id: { type: GraphQLString },
    name: { type: GraphQLString },
    description: { type: GraphQLString },
    image: { type: GraphQLString },
    contributors: {
      type: new GraphQLList(UserType),
      resolve(parentValues, args, request) {
        return Project.findContributors(parentValues.id);
      }
    },
    resources:{
      type: new GraphQLList(ResourceType),
      resolve(parentValues, args, request) {
        return Project.findResources(parentValues.id);
      }
    }
  })
});

module.exports=ProjectType;

schema.js

const graphql = require("graphql");
const RootQuery = require("./RootQueryType");
const Mutation = require("./Mutation");

const { GraphQLSchema } = graphql;

console.log(RootQuery,Mutation);

module.exports = new GraphQLSchema({
  query: RootQuery,
  mutation: Mutation
});

更新：- 我已经删除了资源文件，但我仍然遇到同样的错误，所以它必须在用户和项目类型之间

更新：-我终于找到了项目和用户类型的类型文件中的错误，它是由新的 GraphQLList 引起的，我仍然没有解决错误，但删除它似乎使错误消失，不知道为什么。

Answer 1

终于解决了这个问题，正如@cito 所说，由于循环依赖是导致错误的原因，也就是说我的 UserType 依赖于 ProjectType 并且同样地，因此我收到了这个错误，这被解决了

const graphql = require("graphql");

const User = require("../models/User");
const Project = require("../models/Project");

const {
  GraphQLObjectType,
  GraphQLString,
  GraphQLList,
} = graphql;

const ProjectType = new GraphQLObjectType({
  name: "ProjectType",
  fields: () => ({
    id: { type: GraphQLString },
    name: { type: GraphQLString },
    description: { type: GraphQLString },
    image: { type: GraphQLString },
    contributors: {
      type: new GraphQLList(UserType),
      resolve(parentValues, args, request) {
        return Project.findContributors(parentValues.id);
      }
    },
    resources:{
      type: new GraphQLList(ResourceType),
      resolve(parentValues, args, request) {
        return Project.findResources(parentValues.id);
      }
    }
  })
});

module.exports=ProjectType;



// This is here to prevent circular dependencies problem which will lead to the formation of infinite loop

const UserType = require("./userType");
const ResourceType = require("./resourceType");

需要底部的文件

Answer 2

您的问题是 userType 和 projectType 模块之间的循环依赖关系。因此，const 值在传递给GraphQLList 时仍然是一个空对象。

作为一种解决方案，您可以将所有类型移动到一个模块中。或者，在导出类时，将它们设置为module.exports 的属性。这将起作用，因为您将字段正确定义为 thunk。

顺便说一句，在创建 GraphQLList 或 GraphQLNonNull 包装器时，您不需要 new。但这不是您收到错误的原因。

Answer 3

另一种方法是：

resources:{
      // require directly without creating a new variable
      type: new GraphQLList(require("./resourceType")),

      resolve(parentValues, args, request) {
        return Project.findResources(parentValues.id);
      }
    }