返回突变结果

Question

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

我怀疑是来自突变解析函数（它工作）的返回值存在问题。那么，返回值应该是什么样子？

更高层次的问题是：在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 
    }))); 
}; 

Answer 1

创建的Promise需要返回，每个.then函数也需要返回它的参数。这原来是处理Promises而不是GraphQL问题的问题。

Answer 2

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

您的根查询字段graphUser未得到解决。

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

我怀疑是有来自突变决心功能（工作）的返回值的问题。那么，返回值应该是什么样子？

如果使用Promise，你突变的resolve函数返回一个承诺（不现在回到），并应使用resolve(result)而不是return result。如果用户已经存在，只需返回现有用户对象而不是类型GraphUser。

更高层次的问题是：在GraphQL中是否有一种标准方式来注册一个新用户并处理已存在的用户案例？

GraphQL本身没有处理用户注册的标准方式。你只需要一个突变用户注册。在突变的解析函数中，检查用户是否已经存在。如果存在，突变可能会返回错误。否则，用户注册并返回新创建的用户对象。