Mutation Output Fields about graphql HOT 3 CLOSED

package main

import (
    "errors"
    "github.com/graphql-go/graphql"
    "github.com/graphql-go/graphql/language/ast"
    "github.com/graphql-go/graphql/language/kinds"
    "github.com/kr/pretty"
)

func validate(value string) error {
    return nil
}

var PLID = graphql.NewScalar(graphql.ScalarConfig{
    Name: "PLID",
    Serialize: func(value interface{}) interface{} {
        return value
    },
    ParseValue: func(value interface{}) interface{} {
        var err error
        switch value.(type) {
        case string:
            err = validate(value.(string))
        default:
            err = errors.New("Must be of type string")
        }
        if err != nil {
            // panic(err) // TODO: This panic kills the server
        }
        return value
    },
    ParseLiteral: func(valueAst ast.Value) interface{} {
        if valueAst.GetKind() == kinds.StringValue {
            err := validate(valueAst.GetValue().(string))
            if err != nil {
                panic(err)
            }
            return valueAst
        } else {
            panic("Must be of type string")
        }
    },
})

type User struct {
    ID       string `json:"id"`
    Email    string `json:"email"`
    Password string `json:"password"`
}

var RootMutation = graphql.NewObject(graphql.ObjectConfig{
    Name: "Mutation",
    Fields: graphql.FieldConfigMap{
        "UserLogin": &graphql.FieldConfig{
            Name: "UserLogin",
            Type: PLID, // output is defined as our custom PLID scalar type.
            Args: graphql.FieldConfigArgument{
                "email": &graphql.ArgumentConfig{
                    Type: graphql.NewNonNull(graphql.String),
                },
                "password": &graphql.ArgumentConfig{
                    Type: graphql.NewNonNull(graphql.String),
                },
            },
            Resolve: func(p graphql.GQLFRParams) interface{} {
                // let's just print to verify that we have passed the variables correctly
                // expected output:
                // Arguments map[string]interface {}{
                //      "email": "[email protected]",
                //      "password": "donkeykong",
                // }
                pretty.Println("Arguments", p.Args)

                // marshall and cast the arguments
                email, _ := p.Args["email"].(string)
                password, _ := p.Args["password"].(string)

                // perform mutation operation here
                // ...
                user := &User{
                    ID:       "id007" + email + password,
                    Email:    email,
                    Password: password,
                }

                // I'm assuming this is the desired output (i.e. user.ID: PLID)
                return user.ID
            },
        },
    },
})
var RootQuery = graphql.NewObject(graphql.ObjectConfig{
    Name: "Query",
    Fields: graphql.FieldConfigMap{
        "currentID": &graphql.FieldConfig{
            Type: graphql.String,
        },
    },
})

func main() {

    // define our schema.
    // note that while mutation is optional, root query is not. So we defined a trivial root query here.
    mutationsTestSchema, err := graphql.NewSchema(graphql.SchemaConfig{
        Query:    RootQuery,
        Mutation: RootMutation,
    })
    if err != nil {
        panic(err)
    }

    // the variables that would be passed into `graphql`
    // I've intentionally used `emailVar` and `passwordVar`
    // to make the mutation query easier to understand
    variables := map[string]interface{}{
        "emailVar":    "[email protected]",
        "passwordVar": "donkeykong",
    }

    // our mutation query
    request := `
        mutation Crud($emailVar: String!, $passwordVar: String!) {
          UserLogin(email: $emailVar, password: $passwordVar) {
            user {
                id
                name
                email
            }
          }
        }
    `
    p := graphql.Params{
        Schema:         mutationsTestSchema,
        VariableValues: variables,
        RequestString:  request,
    }
    result := graphql.Graphql(p)
    pretty.Println(result)
    // Expected output:
    //  &graphql.Result{
    //      Data: map[string]interface {}{
    //          "UserLogin": "[email protected]",
    //      },
    //      Errors: nil,
    //  }
}

user := &User{
    ID:       "id007",
    Email:    email,
    Password: password,
}
Arguments map[string]interface {}{
    "email":    "[email protected]",
    "password": "donkeykong",
}
&graphql.Result{
    Data: map[string]interface {}{
        "UserLogin": "&{id007 [email protected] donkeykong}",
    },
    Errors: nil,
}