Node.js，Apollo Server v4，GraphQL，Mongoose - Category Tree

9ceoxa92  于 2024-01-08  发布在  Go
关注(0)|答案(1)|浏览(206)

我正在尝试使用Node.js，Apollo Server v4，GraphQL，Mongoose技术创建类别树。
但是当我想获取创建的类别或子类别数据时，输出不是我想要的。类别既作为引用出现在子类别中，也作为普通类别出现。我还添加了具有此id 655 b105543598 f2 ef 0 ba 0 f69的类别数据，作为具有此id 655 b104 a43598 f2 ef 0 ba 0 f64值的类别的子类别数组中的第2个子类别。我不明白。但是虽然名字不出现空。
GraphQL查询请求;

  1. query Query {
  2.   getCategories {
  3.     success
  4.     response_code
  5.     message
  6.     categories {
  7.       _id
  8.       name
  9.       attributes {
  10.         name
  11.         values {
  12.           value
  13.         }
  14.       }
  15.       products {
  16.         name
  17.       }
  18.       subCategories {
  19.         _id
  20.         name
  21.         attributes {
  22.           name
  23.           values {
  24.             value
  25.           }
  26.         }
  27.         products {
  28.           name
  29.         }
  30.         subCategories {
  31.           _id
  32.           name
  33.           attributes {
  34.             name
  35.             values {
  36.               value
  37.             }
  38.           }
  39.           products {
  40.             name
  41.           }
  42.           subCategories {
  43.             _id
  44.             name
  45.             attributes {
  46.               name
  47.               values {
  48.                 value
  49.               }
  50.             }
  51.             products {
  52.               name
  53.             }
  54.             subCategories {
  55.               _id
  56.               name
  57.               attributes {
  58.                 name
  59.                 values {
  60.                   value
  61.                 }
  62.               }
  63.               products {
  64.                 name
  65.               }
  66.             }
  67.           }
  68.         }
  69.       }
  70.     }
  71.   }
  72. }

字符串
产出;

  1. {
  2.   "data": {
  3.     "getCategories": {
  4.       "success": true,
  5.       "response_code": "categories-successfully-retrieved",
  6.       "message": "Categories Successfully Retrieved!",
  7.       "categories": [
  8.         {
  9.           "_id": "655b103b43598f2ef0ba0f5e",
  10.           "name": "K 2",
  11.           "attributes": {
  12.             "name": null,
  13.             "values": {
  14.               "value": null
  15.             }
  16.           },
  17.           "products": [],
  18.           "subCategories": []
  19.         },
  20.         {
  21.           "_id": "655b103e43598f2ef0ba0f61",
  22.           "name": "K 1",
  23.           "attributes": {
  24.             "name": null,
  25.             "values": {
  26.               "value": null
  27.             }
  28.           },
  29.           "products": [],
  30.           "subCategories": [
  31.             {
  32.               "_id": "655b104a43598f2ef0ba0f64",
  33.               "name": "AK 1",
  34.               "attributes": {
  35.                 "name": null,
  36.                 "values": {
  37.                   "value": null
  38.                 }
  39.               },
  40.               "products": [],
  41.               "subCategories": [
  42.                 {
  43.                   "_id": "655b105543598f2ef0ba0f69",
  44.                   "name": null,
  45.                   "attributes": null,
  46.                   "products": null,
  47.                   "subCategories": null
  48.                 }
  49.               ]
  50.             },
  51.             {
  52.               "_id": "655b106643598f2ef0ba0f6f",
  53.               "name": "AK 2",
  54.               "attributes": {
  55.                 "name": null,
  56.                 "values": {
  57.                   "value": null
  58.                 }
  59.               },
  60.               "products": [],
  61.               "subCategories": []
  62.             }
  63.           ]
  64.         },
  65.         {
  66.           "_id": "655b104a43598f2ef0ba0f64",
  67.           "name": "AK 1",
  68.           "attributes": {
  69.             "name": null,
  70.             "values": {
  71.               "value": null
  72.             }
  73.           },
  74.           "products": [],
  75.           "subCategories": [
  76.             {
  77.               "_id": "655b105543598f2ef0ba0f69",
  78.               "name": "AAK 1",
  79.               "attributes": {
  80.                 "name": null,
  81.                 "values": {
  82.                   "value": null
  83.                 }
  84.               },
  85.               "products": [],
  86.               "subCategories": []
  87.             }
  88.           ]
  89.         },
  90.         {
  91.           "_id": "655b105543598f2ef0ba0f69",
  92.           "name": "AAK 1",
  93.           "attributes": {
  94.             "name": null,
  95.             "values": {
  96.               "value": null
  97.             }
  98.           },
  99.           "products": [],
  100.           "subCategories": []
  101.         },
  102.         {
  103.           "_id": "655b106643598f2ef0ba0f6f",
  104.           "name": "AK 2",
  105.           "attributes": {
  106.             "name": null,
  107.             "values": {
  108.               "value": null
  109.             }
  110.           },
  111.           "products": [],
  112.           "subCategories": []
  113.         }
  114.       ]
  115.     }
  116.   }
  117. }

型
预期产出;

  1. [
  2.   {
  3.   "name": "Category 1",
  4.   "attributes": {
  5.     "name": "Attribute Name",
  6.     "values": [{
  7.       "value": "Attribute Value",
  8.       "products": ["Product Ref", "Product Ref"]
  9.     }]
  10.   },
  11.   "products": ["Product Ref", "Product Ref"],
  12.   "subCategories": [
  13.       {
  14.       "name": "Sub Category 1",
  15.       "attributes": {
  16.         "name": "Attribute Name",
  17.         "values": [{
  18.           "value": "Attribute Value",
  19.           "products": ["Product Ref", "Product Ref"]
  20.         }]
  21.       },
  22.       "products": ["Product Ref", "Product Ref"],
  23.       "subCategories": [
  24.         {
  25.           "name": "Sub Category 2",
  26.           "attributes": {
  27.             "name": "Attribute Name",
  28.             "values": [{
  29.               "value": "Attribute Value",
  30.               "products": ["Product Ref", "Product Ref"]
  31.             }]
  32.           },
  33.           "products": ["Product Ref", "Product Ref"],
  34.           "subCategories": []
  35.         }
  36.       ]
  37.     }
  38.   ]
  39. },
  40. {
  41.   "name": "Category 2",
  42.   "attributes": {
  43.     "name": "Attribute Name",
  44.     "values": [{
  45.       "value": "Attribute Value",
  46.       "products": ["Product Ref", "Product Ref"]
  47.     }]
  48.   },
  49.   "products": ["Product Ref", "Product Ref"],
  50.   "subCategories": [
  51.       {
  52.       "name": "Sub Category 1",
  53.       "attributes": {
  54.         "name": "Attribute Name",
  55.         "values": [{
  56.           "value": "Attribute Value",
  57.           "products": ["Product Ref", "Product Ref"]
  58.         }]
  59.       },
  60.       "products": ["Product Ref", "Product Ref"],
  61.       "subCategories": [
  62.         {
  63.           "name": "Sub Category 2",
  64.           "attributes": {
  65.             "name": "Attribute Name",
  66.             "values": [{
  67.               "value": "Attribute Value",
  68.               "products": ["Product Ref", "Product Ref"]
  69.             }]
  70.           },
  71.           "products": ["Product Ref", "Product Ref"],
  72.           "subCategories": []
  73.         }
  74.       ]
  75.     }
  76.   ]
  77. }
  78. ]

型
范畴 Mongoose 图式;

  1. import mongoose from "mongoose";
  3. const attributeSchema = new mongoose.Schema({
  4.   name: { type: String, required: true, trim: true, unique: true, default: "Default Name" },
  5.   values: [
  6.     {
  7.       value: { type: String, required: true, trim: true, unique: true },
  8.       products: [{ type: mongoose.Schema.Types.ObjectId, ref: "Product" }],
  9.     },
  10.   ],
  11. });
  13. const categorySchema = new mongoose.Schema({
  14.   name: { type: String, required: true, trim: true },
  15.   subCategories: [{ type: mongoose.Schema.Types.ObjectId, ref: "Category" }],
  16.   attributes: [attributeSchema],
  17.   products: [{ type: mongoose.Schema.Types.ObjectId, ref: "Product" }],
  18. });
  20. export const Category = mongoose.model("Category", categorySchema);

型
类别GraphQL模式;

  1. export const categorySchema = `#graphql
  2.   type Category {
  3.     _id: ID
  4.     name: String
  5.     subCategories: [Category]
  6.     attributes: Attributes
  7.     products: [Product]
  8.   }
  10.   input CategoryInput {
  11.     name: String!
  12.     isMainCategory: Boolean!
  13.     parentCategoryID: ID
  14.   }
  16.   type Attributes {
  17.     name: String
  18.     values: AttributesValue
  19.   }
  21.   type AttributesValue {
  22.     value: String
  23.     products: [Product]
  24.   }
  26.   input AttributesInput {
  27.     name: String!
  28.     categoryID: ID!
  29.   }
  31.   input AttributesValueInput {
  32.     value: String!
  33.     attributesID: ID!
  34.   }
  36.   type QueryCategoryResponse {
  37.     success: Boolean!
  38.     response_code: String!
  39.     message: String!
  40.     category: Category
  41.     categories: [Category]
  42.   }
  44.   type Query {
  45.     getCategories: QueryCategoryResponse
  46.     getCategoryByID(id: ID!): QueryCategoryResponse
  47.     getCategoriesByID(ids: [ID]!): QueryCategoryResponse
  48.   }
  50.   type Mutation {
  51.     createCategory(input: CategoryInput!): Response
  52.   }
  53. `;

型
类别解析器;

  1. import { Category } from "./model.js";
  3. export const categoryResolver = {
  4.   Query: {
  5.     getCategories: async () => {
  6.       try {
  7.         const categories = await Category.find().populate("subCategories attributes products");
  9.         if (categories) {
  10.           return {
  11.             success: true,
  12.             response_code: "categories-successfully-retrieved",
  13.             message: "Categories Successfully Retrieved!",
  14.             categories: categories,
  15.           };
  16.         } else {
  17.           return { success: false, response_code: "categories-not-found", message: "Categories Not Found!" };
  18.         }
  19.       } catch (error) {
  20.         return { success: false, response_code: "server-error", message: "Server Error!" };
  21.       }
  22.     },
  23.     getCategoryByID: async (_, { id }) => {
  24.       try {
  25.         const category = await Category.findById({ _id: id }).populate("subCategories attributes products");
  27.         if (category) {
  28.           return {
  29.             success: true,
  30.             response_code: "category-successfully-retrieved",
  31.             message: "Category Successfully Retrieved!",
  32.             category: category,
  33.           };
  34.         } else {
  35.           return { success: false, response_code: "category-not-found", message: "Category Not Found!" };
  36.         }
  37.       } catch (error) {
  38.         return { success: false, response_code: "server-error", message: "Server Error!" };
  39.       }
  40.     },
  41.     getCategoriesByID: async (_, { ids }) => {
  42.       try {
  43.         const categories = await Category.find({ _id: { $in: ids } }).populate("subCategories attributes products");
  45.         if (categories.length !== 0) {
  46.           return {
  47.             success: true,
  48.             response_code: "categories-successfully-retrieved",
  49.             message: "Categories Successfully Retrieved!",
  50.             categories: categories,
  51.           };
  52.         } else {
  53.           return { success: false, response_code: "categories-not-found", message: "Categories Not Found!" };
  54.         }
  55.       } catch (error) {
  56.         return { success: false, response_code: "server-error", message: "Server Error!" };
  57.       }
  58.     },
  59.   },
  60.   Mutation: {
  61.     createCategory: async (_, { input }) => {
  62.       try {
  63.         if (input.isMainCategory) {
  64.           const category = await Category.findOne({ name: input.name }).collation({ locale: "en", strength: 2 });
  66.           if (category) {
  67.             return { success: false, response_code: "category-name-exist", message: "Category Name Exist!" };
  68.           } else {
  69.             const newCategory = new Category({
  70.               name: input.name,
  71.             });
  73.             await newCategory.save();
  75.             return {
  76.               success: true,
  77.               response_code: "category-created-successfully",
  78.               message: "Category Created Successfully!",
  79.             };
  80.           }
  81.         } else {
  82.           const category = await Category.findById(input.parentCategoryID).populate("subCategories");
  84.           if (!category) {
  85.             return { success: false, response_code: "sub-category-not-found", message: "Sub Category Not Found!" };
  86.           }
  88.           const categoryNames = category.subCategories.map((category) => category.name.toLowerCase());
  90.           if (categoryNames.includes(input.name.toLowerCase())) {
  91.             return { success: false, response_code: "category-name-exist", message: "Category Name Exists!" };
  92.           }
  94.           const newCategory = new Category({
  95.             name: input.name,
  96.           });
  98.           await newCategory.save();
  100.           category.subCategories.push(newCategory);
  101.           await category.save();
  103.           return {
  104.             success: true,
  105.             response_code: "sub-category-created-successfully",
  106.             message: "Sub Category Created Successfully!",
  107.           };
  108.         }
  109.       } catch (error) {
  110.         console.log(error);
  111.         return { success: false, response_code: "server-error", message: "Server Error!" };
  112.       }
  113.     },
  114.   },
  115. };

型
我如何改进这段代码并解决我的getCategories输出问题？
显然，我也尝试过mongoose ref，我也尝试过根据categorySchema直接将数据发送到子类别中。我在第二个方法中提到的添加子类别的方法对我来说是一个头痛的问题。

mongoose

1条答案

按热度按时间
e5njpo68

e5njpo681#

你的模型中似乎缺少了parent类别的概念。当定义一个层次模型时，通常包括对父类别的引用（类似于parentId）。
然后返回所有类别，首先搜索所有具有nullparentId的类别-这些是根节点。
你还需要一个子类别的字段解析器来查找父类别是当前类别的类别。这允许你递归地遍历树。
GraphQL的一个限制是你必须明确你想在你的查询中带回多少层，你不能定义一个递归树，它会向下钻取到每一个可能的叶子。你上面的查询向下钻取5层。
首先，在GraphQL类型中，添加一个parent字段。

  1. type Category {
  2.   _id: ID
  3.   name: String
  4.   subCategories: [Category]
  5.   parent: Category
  6.   attributes: Attributes
  7.   products: [Product]
  8. }

字符串
在Mongoose模型中：

  1. const categorySchema = new mongoose.Schema({
  2.   name: { type: String, required: true, trim: true },
  3.   subCategories: [{ type: mongoose.Schema.Types.ObjectId, ref: "Category" }],
  4.   parentId: { type: mongoose.Schema.Types.ObjectId, required: false },
  5.   attributes: [attributeSchema],
  6.   products: [{ type: mongoose.Schema.Types.ObjectId, ref: "Product" }],
  7. });

型
然后修改getCategories解析器以搜索parentId为空的类别
然后向Category类型添加一个字段解析器来解析基于parentId的子类别，并添加一个字段解析器来解析父类别。
现在，相对于您的values结构-您定义它的方式，它严格地位于Mongoose模型的内部;如果你想通过value嵌套结果，那么你需要在Category类型中添加一个value字段，并定义一个包含value和products的Value类型，即

  1. type Value {
  2.   attributes: Attributes
  3.   products: [Product]
  4. }
  5. type Category {
  6.   _id: ID
  7.   name: String
  8.   subCategories: [Category]
  9.   parent: Category
  10.   value: Value
  11. }

型
定义一个 pluraltype（例如：Attributes）是不常见的。类型通常是单数的，因为如果你想要几个类型，你只需要把它们组成一个数组。你想在一个 field 名称中使用复数形式，而不是一个 type 名称。

展开查看全部
赞(0）分享  回复(0）举报  2024-01-08
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com