Graphql 从突变中返回结果

我的直接问题是为什么不调用查询解析函数

我怀疑变异解析函数的返回值有问题（该函数有效）。那么，返回值应该是什么样的呢

一个更高层次的问题是：在GraphQL中是否有注册新用户并处理已存在用户的情况的标准方法

下面的方法是在会话数据中包含关于用户的所有数据，并仅传回前端需要的数据

/**
 * graphQL.js
 *
 * Created by jrootham on 18/04/16.
 *
 * Copyright © 2016 Jim Rootham
 */

import graphqlHTTP from "express-graphql";
import {
    graphql,
    GraphQLSchema,
    GraphQLObjectType,
    GraphQLString,
    GraphQLNonNull,
    GraphQLBoolean
} from 'graphql';
import {hash} from "bcrypt"
import {connect, User} from "../database/defineDB";

const GraphUser = new GraphQLObjectType({
    name: "GraphUser",
    description: "A user object",
    fields: () => {
        return {
            name: {
                type: GraphQLString,
                resolve: (_, __, session) => {
                    console.log("resolve name", session);
                    let name = "";
                    if (session.signedOn) {
                        return User.findById(session.userId).then (user => {
                            return user.name;
                        });
                    }

                    console.log("name", name);
                    return name;
                }
            },
            signedOn: {
                type: GraphQLBoolean,
                resolve: (_, __, session) => {
                    return session.signedOn;
                }
            },
            existed: {
                type: GraphQLBoolean,
                resolve: (_, __, session) => {
                    return session.existed;
                }
            }
        }
    }
});

const query = new GraphQLObjectType({
    name: 'Queries',
    fields: () => {
        return {
            graphUser: {
                type: GraphUser
            }
        }
    }
});

const mutation = new GraphQLObjectType({
    name: 'Mutations',
    description: "Modification actions",
    fields() {
        return {
            registerUser: {
                type: GraphUser,
                args: {
                    name: {
                        type: new GraphQLNonNull(GraphQLString)
                    },
                    password: {
                        type: new GraphQLNonNull(GraphQLString)
                    }
                },
                resolve(_, args, session) {
                    console.log("resolve", args);
                    User.findOne({where:{name:args.name}}).then(user => {
                        console.log("After find", user);
                        if (user === null) {
                            const getHash = new Promise(
                                resolve => {
                                    hash(args.password, 10, (err, hash) => {
                                        resolve(hash);
                                    });
                                }
                            );

                            const result = getHash.then(hash => {
                                connect.models.user.create({
                                    name: args.name,
                                    password: hash
                                }).then(user => {
                                    session.userId = user.id;
                                    session.signedOn = true;
                                    session.existed = false;

                                    console.log("session user", session.userId);
                                    return user;
                                });

                                console.log(result);
                                return result;
                            });
                        }
                        else {
                            session.userId = 0;
                            session.signedOn = false;
                            session.existed = true;
                            console.log("existed");
                            return GraphUser;
                        }
                    });
                }
            }
        }
    }
});

const schema = new GraphQLSchema({
    query: query,
    mutation: mutation
});

export const useGraphQL = app => {
    app.use('/graphql', graphqlHTTP(request =>({
        schema: schema,
        context: request.session,
        formatError: error => ({
            message: error.message,
            locations: error.locations,
            stack: error.stack
        }),
        graphiql:true
    })));
};

---

为什么不调用查询解析函数？

无法解析根查询字段

graphUser

const query = new GraphQLObjectType({
    name: 'Queries',
    fields: () => {
        return {
            graphUser: {
                type: GraphUser
                // TODO Add a resolve function here
            }
        }
    }
});

我怀疑变异解析函数的返回值有问题（该函数有效）。那么，返回值应该是什么样子？

如果您使用

Promise

，您的变异的

resolve

函数应该返回一个Promise（现在不返回），并且应该使用

resolve（result）

而不是

返回结果。如果用户已经存在，只需返回现有的用户对象，而不是键入
GraphUser

一个更高层次的问题是：GraphQL中是否有注册新用户并处理现有用户情况的标准方法？

GraphQL本身没有处理用户注册的标准方法。用户注册只需要一个变种。在变异的解析函数中，检查用户是否已经存在。如果存在，变异可能返回错误。否则，将注册用户并返回新创建的用户对象。
需要返回已创建的承诺，每个。然后函数还需要返回其参数。这是一个问题，而不是GraphQL问题。
根查询只是一个占位符。解决它没有任何效果。答案的承诺部分只是一个线索，但并不完整，请参见下文。Re:root查询，它不仅仅是占位符。除非您解决了它，否则无法对其进行查询。Re:promise部分，只有您可以根据您的业务逻辑了解完整的实现。我试着给你指出正确的方向。你总共有3个问题：-）@OP，你不应该改变问题的内容。变异代码被改变了？