Question

这与我的上一个问题here密切相关。简而言之，我有2个架构， dbPosts 和 dbAuthors 。它们看起来有点像这样（为简洁起见，我在这里省略了一些字段）：

dbPosts

id: mongoose.Schema.Types.ObjectId,
title: { type: String },
content: { type: String },
excerpt: { type: String },
slug: { type: String },
author: {
   id: { type: String },
   fname: { type: String },
   lname: { type: String },
}

dbAuthors

id: mongoose.Schema.Types.ObjectId,
fname: { type: String },
lname: { type: String },
posts: [
         id: { type: String },
         title: { type: String }
       ]

我正在解决这样的 post 查询：

const mongoose = require('mongoose');
const graphqlFields = require('graphql-fields');
const fawn = require('fawn');
const dbPost = require('../../../models/dbPost');
const dbUser = require('../../../models/dbUser');

fawn.init(mongoose);

module.exports = {
  // Queries
  Query: {
    posts: (root, args, context) => {
      return dbPost.find({});
    },
    post: (root, args, context) => {
      return dbPost.findById(args.id);
    },
  },

  Post: {
    author: (parent, args, context, ast) => {
      // Retrieve fields being queried
      const queriedFields = Object.keys(graphqlFields(ast));
      console.log('-------------------------------------------------------------');
      console.log('from Post:author resolver');
      console.log('queriedFields', queriedFields);
      // Retrieve fields returned by parent, if any
      const fieldsInParent = Object.keys(parent.author);
      console.log('fieldsInParent', fieldsInParent);
      // Check if queried fields already exist in parent
      const available = queriedFields.every((field) => fieldsInParent.includes(field));
      console.log('available', available);
      if(parent.author && available) {
        return parent.author;
      } else {
        return dbUser.findOne({'posts.id': parent.id});
      }
    },
  },
};

我正在解决所有这样的 author 查询：

const mongoose = require('mongoose');
const graphqlFields = require('graphql-fields');
const dbUser = require('../../../models/dbUser');
const dbPost = require('../../../models/dbPost');

module.exports = {
  // Queries
  Query: {
    authors: (parent, root, args, context) => {
      return dbUser.find({});
    },
    author: (root, args, context) => {
      return dbUser.findById(args.id);
    },
  },

  Author: {
    posts: (parent, args, context, ast) => {
      // Retrieve fields being queried
      const queriedFields = Object.keys(graphqlFields(ast));
      console.log('-------------------------------------------------------------');
      console.log('from Author:posts resolver');
      console.log('queriedFields', queriedFields);
      // Retrieve fields returned by parent, if any
      const fieldsInParent = Object.keys(parent.posts[0]._doc);
      console.log('fieldsInParent', fieldsInParent);
      // Check if queried fields already exist in parent
      const available = queriedFields.every((field) => fieldsInParent.includes(field));
      console.log('available', available);
      if(parent.posts && available) {
        // If parent data is available and includes queried fields, no need to query db
        return parent.posts;
      } else {
        // Otherwise, query db and retrieve data
        return dbPost.find({'author.id': parent.id, 'published': true});
      }
    },
  },
};

为了简洁起见，我再次省略了与该问题无关的位，例如突变。我的目标是使所有查询都可以递归工作，同时还可以优化数据库查找。但是，我无法以某种方式完成此任务。例如，这是我正在运行的查询：

{
  posts{
    id
    title
    author{
      first_name
      last_name
      id
      posts{
        id
        title
      }
    }
  }
}

它返回此：

{
  "errors": [
    {
      "message": "Cannot return null for non-nullable field Post.author.",
      "locations": [
        {
          "line": 5,
          "column": 5
        }
      ],
      "path": [
        "posts",
        1,
        "author"
      ]
    }
  ],
  "data": {
    "posts": [
      {
        "id": "5ba1f3e7cc546723422e62a4",
        "title": "A Title!",
        "author": {
          "first_name": "Bill",
          "last_name": "Erby",
          "id": "5ba130271c9d440000ac8fc4",
          "posts": [
            {
              "id": "5ba1f3e7cc546723422e62a4",
              "title": "A Title!"
            }
          ]
        }
      },
      null
    ]
  }
}

如果您注意到，该查询会返回所有请求的值，但还会针对 post.author 查询添加一条错误消息！可能是什么原因造成的？

我没有包括整个代码库，以免引起混乱，但是如果您希望看一看，它在Github上，而GraphiQL接口在https://graph.schandillia.com上希望自己查看结果。

如果您走了这么远，非常感谢您的时间。真的很感激任何朝着正确方向的指针！”

P.S。：如果您注意到，我正在记录每个解析器中3个变量的值以进行调试：

queriedFields ：要查询的所有字段的数组
fieldsInParent ：解析器的 parent 属性中返回的所有字段的数组
可用：一个布尔值，显示 fieldsInParent

queriedFields

当我运行这样的简单查询时：

{
  posts{
    id
    author{
      id
      posts{
        id
      }
    }
  }
}

这是记录的内容：

-------------------------------------------------------------
from Post:author resolver
queriedFields [ 'id', 'posts' ]
fieldsInParent [ '$init', 'id', 'first_name', 'last_name' ]
available false
-------------------------------------------------------------
from Post:author resolver
queriedFields [ 'id', 'posts' ]
fieldsInParent [ '$init', 'id', 'first_name', 'last_name' ]
available false
-------------------------------------------------------------
from Author:posts resolver
queriedFields [ 'id' ]
fieldsInParent [ 'id', 'title' ]
available true

post：author 解析程序是否应该只执行一次？另外，很有趣的是，即使 author 的模式包括这样的字段，在前2个日志中 fieldsInParent 仍然缺少 posts 字段。 / p>

Answer 1

您的查询结果实际上不包括所有请求的数据。 posts查询解析为一个包含一个Post对象和一个null的数组。之所以存在null，是因为GraphQL试图完全解析另一个Post对象，并且不能-遇到验证错误，即帖子的作者解析为null。

您可以更改架构以使author字段可为空，这将消除错误，但仍会留下空帖。大概，如果一个帖子存在，它应该有一个作者（尽管在MongoDB中，我想很可能只有一些不好的数据）。如果您在解析器内部查看，则有两个{{1}}语句-其中一个（可能是db调用）正在为第二个帖子返回null。

顺便说一句，作为客户端，您可能不想处理数组内的null，而是希望使用空数组代替整个字段的null。使用列表（数组）时，您可能希望使它们都不能为空，并使该列表中的每个项目也不能为空。您是这样的：

return

您仍然需要确保解析程序逻辑阻止这些null的发生，但是添加验证可以帮助您更轻松地捕获这种行为。

尝试递归运行GraphQL查询以及查询结果时出错

1 个答案: