graphql中resolver函数不同实现的解释

Question

我一直在阅读graphQL文档，发现他们以两种方式解释了graphql服务器的实现：一种使用graphql-yoga，它是一个功能齐全的graphql服务器，另一种使用graphql、express-graphql和express . 在这两种情况下，我们在创建服务器实例时传递架构和解析器函数。

但是解析器功能的实现不同。在使用 graphql-yoga 时，解析器函数提供了 4 个参数，其中包含有关父对象的信息、接收的参数、上下文、信息。而在另一种情况下（使用 graphql），解析器函数只获取参数对象。

为什么呢 ？如果我想要信息、上下文对象，我该如何获取？

使用 graphql-yoga 示例： https

使用 graphql 示例： https

// 使用graphql的代码示例

var express = require('express');
var graphqlHTTP = require('express-graphql');
var { buildSchema } = require('graphql');

var schema = buildSchema(`
type Query {
    rollDice(numDice: Int!, numSides: Int): [Int]
}
type Mutation {
    addDice(numDice: Int): String
}
`);

var root = {
    rollDice({numDice, numSides}) {
        return [1, 2];
    },
    addDice({numDice}) {
        console.log("Adding something");
        return "Added";
    }
};

var app = express();
app.use('/graphql', graphqlHTTP({
    schema: schema,
    rootValue: root,
    graphiql: true,
}));
app.listen(4000);
console.log('Running a GraphQL API server at localhost:4000/graphql');

// 使用graphql-yoga的代码示例

let graphqlServer = require("graphql-yoga");

const typeDefs = `
    type Query {
        rollDice(numDice: Int!, numSides: Int): [Int]
    }
    type Mutation {
        addDice(numDice: Int): String
    }
    `;

const resolvers = {
    Query: {
        rollDice(parent, args, context, info) {
            console.log(args.numDice);
            console.log(args.numSides);
            return [1, 2];
        }
    },
    Mutation: {
        addDice(parent, args, context, info) {
            console.log(args.numDice);
            return "Added";
        }
    }
};

const server = new graphqlServer.GraphQLServer({
    typeDefs,
    resolvers
});

server.start(() => {
    console.log("server started on localhost:4000");
});

这两个代码片段之间的区别：

在一种情况下，解析器函数存在于适当的类型（即查询、变异）中。在另一种情况下，它们存在于一个根对象中。这意味着在第一种情况下我可以在 Query 和 Mutation 中使用同名的方法，而在第二种情况下这是不可能的，因为它们是单个对象的键并且键应该是唯一的。

为什么会这样？我基本上错过了什么吗？一个包与另一个包的实现细节有何不同？

Answer 1

实谈：在GraphQL.js文档是不是很大。在我看来，他们一开始就不应该使用示例，buildSchema因为它会导致这种混淆是可以理解的。

GraphQL.js（即graphql包）是 GraphQL 的 JavaScript 实现。在 GraphQL.js 中构建模式是通过构建GraphQLSchema类的实例以编程方式完成的：

const userType = new GraphQLObjectType({
  name: 'User',
  fields: {
    id: {
      type: GraphQLID,
    },
    email: {
      type: GraphQLString,
    },
  },
});
const queryType = new GraphQLObjectType({
  name: 'Query',
  fields: {
    user: {
      type: userType,
      resolve: () => ({ id: 1, email: 'john.doe@example.com' }),
    },
  },
});
const schema = new GraphQLSchema({
  query: queryType,
})

如果我们用架构定义语言 (SDL) 打印这个架构，它看起来像这样：

type Query {
  user: User
}

type User {
  id: ID
  email: String
}

使用 SDL 比编写所有代码要容易得多。但是，GraphQL.js 没有提供从 SDL 构建功能齐全的模式的方法。它确实提供了一个buildSchema功能，但该实用程序构建了一个没有任何解析器的模式（以及许多其他功能，如联合/接口类型解析）。

该graphql-tools包提供了一个makeExecutableSchema函数，可让您从 SDL 和解析器映射对象构建架构。这就是apollo-server和在幕后使用的内容graphql-yoga。makeExecutableSchema使用 SDL 从 SDL 构造一个模式buildSchema，然后改变结果对象，在事后添加解析器。

在 GraphQL.js 中，resolve字段的函数（或解析器）有四个参数——父值、字段的参数、上下文和GraphQLResolveInfo对象。如果我们在上面的例子中创建一个GraphQLObjectTypelike userType，这是我们可以为对象中的每个字段提供的可选函数。这与您在构建解析器映射以用于 时定义的函数相同graphql-yoga。这是字段解析器的唯一实现。

所以这是怎么回事buildSchema？？

文档中的示例利用了 GraphQL 的默认字段解析器：

export const defaultFieldResolver: GraphQLFieldResolver<any, *> = function(
  source,
  args,
  contextValue,
  info,
) {
  if (typeof source === 'object' || typeof source === 'function') {
    const property = source[info.fieldName];
    if (typeof property === 'function') {
      return source[info.fieldName](args, contextValue, info);
    }
    return property;
  }
};

如您所见，默认解析逻辑会查找与源（父）值上的字段同名的属性。在我们上面的例子中，user解析器返回{id: 1, email: 'john.doe@example.com'}——这是字段解析为的值。该字段的类型为User。我们没有为我们的id字段定义解析器，所以默认解析器会做它的事情。该id字段解析为，1因为这是名为的属性的值id是解析器接收的父对象上。

但是，父值也可以是函数而不是对象。如果它是一个函数，则首先调用它，然后使用返回值。该函数用什么调用？好吧，它不能向它传递父值（因为无限递归），但它可以向它传递剩余的三个参数（args、context 和 info）。所以这就是它的作用。

现在是魔术

在我们的示例中，我可以省略user字段的解析器，而是将函数传递给根值。

const root = {
  user: () => ({id: 1, email: 'john.doe@example.com'})
}

根对象只是一个可选对象，它作为父值传递给根级别的解析器（如您的Query或Mutation类型）。否则，这些解析器将没有父值。

Query是一个可操作的根类型——它充当架构其余部分的“入口点”。Query类型上的任何字段都将作为父值传递给根对象。如果我省略user字段的解析器，默认解析器将 1) 检查父对象的同名属性，2) 查找属性并确定它是一个函数，3) 调用该函数，4) 解析该字段到函数的返回值。

多田！

但是，由于该函数是由默认解析器调用的，并且本身不用作解析器，因此它只会接收上述三个参数，而不是 4 个。

这是解决无法为模式实际提供自定义解析器的一种巧妙方法，但它非常有限。它仅适用于根类型，因此我们不能类似地为User字段或其他类型提供假解析器。我们不能在我们的模式中使用接口或联合，因为我们不能提供resolveType函数。等等...

希望这提供了一些清晰度。希望我们可以在不久的将来更新文档，以避免所有这些混乱。