Question

我正在实现apollo服务器graphql模式。我所有的架构定义都是.graphql文件中的模块。我所有的解析器都是.js文件中的模块。

我具有以下类型：

productSchema.graphql

type Product {
  _id: Int
  company: Company
  productSellingPrice: [PriceHistoryLog]
  productName: String
  category: String
  productDetails: [ProductDetail]
  globalId: Int
  isActive: Boolean
}

extend type Query {
  ProductList: [Product]
}

productDetailSchema.graphql

 type ProductDetail {
   _id: Int
   company: Company
   root: Product
   catalogItem: CatalogItem
   product: Product
   isPerishable: Boolean
   quantity: Float
   isActive: Boolean
 }

 extend type Query { 
   ProductDetailsList(productId: Int!): [ProductDetail]
  }

我想做的是，在查询ProductList时，运行ProductDetailsList查询并从那里解析product中的字段。

如您所见，ProductDetail也具有嵌套字段，因此我不能仅在Product解析器中查询数据库中的该字段。

有什么想法吗？我有点迷路。

编辑：

这是我的解析器代码：

Product: {
    company: product => product.companyId,
    category: async product => {
       try {
         let res = await SaleModel.findOne({ productName: 
          product.productName }) ;
          return res.productCategory;
          } catch (err) {
           console.log(err);
         return "Mo Category found";
       }
      }
    },
   Query: {
     async ProductList(obj, args, { companyId }) {
       return await ProductModel.find({
    companyId,
    isActive: true
  }).populate("companyId");
    }
   },

Answer 1

您可以通过从graphql模块导入并使用graphql函数来手动执行GraphQL请求：

const { graphql } = require('graphql')

const { data, errors } = await graphql(
  schema,
  queryString,
  rootValue,
  context,
  variables
)

但是，实际上不需要这样做，尤其是在这种情况下。您只需要为应该从该数据库返回资源的每个字段添加一个解析器。我在这里做一些假设，但是看起来像这样：

const resolvers = {
  Query: {
    ProductList: (obj, args, { companyId }) => {
      return ProductModel.find({ companyId, isActive: true })
    }
    ProductDetailsList: (obj, { productId }) => {
      return ProductDetail.find({ productId })
    }
  },
  Product: {
    company: ({ companyId }) => {
      return CompanyModel.findById(companyId)
    }
    productDetails: ({ id }) => {
      return ProductDetail.find({ productId: id })
    }
    // and so on...
  },
  ProductDetail: {
    company: ({ companyId }) => {
      return CompanyModel.findById(companyId)
    }
    product: ({ productId }) => {
      return ProductModel.findById(productId)
    }
    // and so on..
  },
}

一旦完成这项工作，您可能会发现对数据库的调用比您真正想要的更多。如果您到了这一步，那么我将实施DataLoader来帮助您批量处理这些呼叫。

从解析器内部运行graphql查询-用于嵌套数据

1 个答案: