Resolver 必须是对象或函数（Graphql 关系）

Question

我正在尝试在类别和产品之间建立一对多关系，但在我放置解析器后出现错误，这是我的代码供参考。

错误显示：

产品解析器：

 async getProductByCategory(mainCategory, {}) {
      try {
        const product = Product.find({ mainCategory: mainCategory._id });
        if (product) {
          return product;
        } else {
          throw new Error("Product Not Found");
        }
      } catch (err) {
        throw new Error(err);
      }
    },

MainCategory 解析器：

async getCategoryByProduct(product, args) {
      try {
        const mainCategory = MainCategory.findById(product._id);
        if (mainCategory) {
          return mainCategory;
        } else {
          throw new Error("Main Category Not Found");
        }
      } catch (err) {
        throw new Error(err);
      }
    },

主解析器：

const productsResolvers = require("./products");
const mainCategoriesResolvers = require("./mainCategories");


module.exports = {
    Product: {
      mainCategory: productsResolvers.getProductByCategory,
    },
    MainCategory: {
      products: mainCategoriesResolvers.getCategoryByProduct,
    },
    Query: {
      ...productsResolvers.Query,
      ...mainCategoriesResolvers.Query,
    },
    Mutation: {
      ...productsResolvers.Mutation,
      ...mainCategoriesResolvers.Mutation,
    },
   
  };

typeDefs:

type Product {
    id: ID! 
    mainCategory: MainCategory
  }

 type MainCategory {
    id: ID!
    products: [Product]
  }

如果您还需要代码参考，请告诉我，我可以给您。提前致谢

Answer 1

大家好，我已经为那些想了解 graphql 中的一对多关系的人解决了这个问题，这是我所做的代码。

产品型号：

const { model, Schema } = require("mongoose");

const { ObjectId } = Schema.Types;

const productSchema = new Schema({
  name: String,
  mainCategory: {
    type: ObjectId,
    ref: "MainCategory",
  },
});

module.exports = model("Product", productSchema);

我们只想让 mainCategory 字段或数据成为一个对象，因为我们只希望每个产品都有一个类别，你看到的 ref 应该与你在这里命名的模型完全一样:

module.exports = model("MainCategory", mainCategorySchema);

对于 MainCategory 模型：

const { model, Schema } = require("mongoose");

const { ObjectId } = Schema.Types;

const mainCategorySchema = new Schema({
  products: [
    {
      type: ObjectId,
      ref: "Product",
    },
  ],
});

module.exports = model("MainCategory", mainCategorySchema);

你分类对了吗？ category 可以有多个产品，所以我们把它做成一个数组，然后像 Product 一样，我们应该使 ref 类似于我们命名模型。

现在，TypeDefs:

type Product {
    id: ID!
    mainCategory: MainCategory!
  }

我们只将它设为 MainCategory！因为我们只想 return 一个对象。

type MainCategory {
    id: ID!
    name: String!
    products: [Product!]
  }

对于 MainCategory 类型，我们将其设为 [Product!]，因为我们只想 return 一个数组。

现在在 typedefs 中进行查询：

type Query {
 getProducts: [Product]
 getMainCategories: [MainCategory]
}

这将获取产品和主要类别的所有数据

因为我们需要改变数据或者换句话说创建数据，我们可以这样做：

type Mutation {
    createProduct(
      name:String!
      mainCategory: String!
    ): Product!
     createMainCategory(
      name: String!
    ): MainCategory!
}

正如你现在问的那样？为什么 mainCategory 是一个字符串？为什么？因为我们要发送对象 ID 或类别的 ID。

如您所见，我们没有产品 createMainCategory，因为我们将在创建产品时获取该 ID，稍后我将对此进行解释。

然后我们转到这里的解析器：

产品解析器：

const Product = require("../../models/Product");

module.exports = {
  Query: {
    async getProducts() {
      try {
        const products = await Product.find().sort({ createdAt: -1 });
        return products;
      } catch (err) {
        throw new Error(err);
      }
    },
  },
  Mutation: {
    async createProduct(_, { mainCategory }, context) {
      const newProduct = new Product({
        mainCategory,
      });

      const product = await newProduct.save();

      return product;
    },
  },
};

MainCategory 解析器：

const MainCategory = require("../../models/MainCategories");

module.exports = {
  Query: {
    async getMainCategories() {
      try {
        const mainCategories = await MainCategory.find().sort({
          createdAt: -1,
        });
        return mainCategories;
      } catch (err) {
        throw new Error(err);
      }
    },
  },
  Mutation: {
    async createMainCategory(_, { name }, context) {
      const newMainCategory = new MainCategory({
        name,
      });

      const mainCategory = await newMainCategory.save();

      return mainCategory;
    },
  },
};

然后最后在 index.js:

Product: {
    mainCategory: (parent) => 
    MainCategory.findById(parent.mainCategory),
},

MainCategory: {
    products: (parent) => Product.find({ mainCategory: parent._id 
}),

我们在这里定义我们使用了我使用 parent 的原因，这样我就不会混淆它是产品还是 maincategory 所以在产品中你必须定义在这种情况下我们使用 mainCategory 字段，我们使用 MainCategory 模型注意，我们使用作为产品的父级来获取作为对象 ID 的 mainCategory 字段，它将 return 给我们具有相同 ID 的类别

为了让 mainCategory 获取产品数组，我们使用 Product 模型，请注意并找到相同的 mainCategory 和作为 mainCategory Id 的父 id，它将 return 数组产品数量

这是你的结果： 我们先查询 Products

结果：

同样适用于 mainCategory 我们首先查询 getMainCategories

则结果：

注意，我做的是一对多关系 如果您对此有任何错误，请告诉我，我经常活跃在 Whosebug 上，但我可能会迟到回复，但我会在看到通知时立即回复。

Resolver 必须是对象或函数（Graphql 关系）

Resolver must be an object or function (Graphql Relationship)

mongoose

mongodb

apollo

graphql

apollo-server