Requests are not validated before execution (`validator` has not been implemented) about graphql HOT 4 CLOSED

package main

import (
    "errors"

    "github.com/graphql-go/graphql"
    "github.com/graphql-go/graphql/language/ast"
    "github.com/graphql-go/graphql/language/kinds"
)

func validate(value string) error {
    if len(value) < 3 {
        return errors.New("The minimum length required is 3")
    }
    return nil
}

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

    ObjectType := graphql.NewObject(graphql.ObjectConfig{
        Name:        "User",
        Description: "A typical user",
        Fields: graphql.Fields{
            "id": &graphql.Field{
                Type: ID,
            },
        },
    })

    Schema, err := graphql.NewSchema(graphql.SchemaConfig{
        Query: graphql.NewObject(graphql.ObjectConfig{
            Name: "Query",
            Fields: graphql.Fields{
                "object": &graphql.Field{
                    Type: ObjectType,
                    Resolve: func(p graphql.ResolveParams) (interface{}, error) {
                        return map[string]interface{}{
                            "id": "test",
                        }, nil
                    },
                },
            },
        }),
        Mutation: graphql.NewObject(graphql.ObjectConfig{
            Name: "Mutation",
            Fields: graphql.Fields{
                "ObjectCreate": &graphql.Field{
                    Type: ObjectType,
                    Args: graphql.FieldConfigArgument{
                        "id": &graphql.ArgumentConfig{
                            Type: ID,
                        },
                    },
                    Resolve: func(p graphql.ResolveParams) (interface{}, error) {
                        return map[string]interface{}{
                            "id": "test",
                        }, nil
                    },
                },
            },
        }),
    })
    if err != nil {
        panic(err)
    }

    // // Returns the right error
    // params := graphql.Params{
    //  Schema: Schema,
    //  RequestString: `
    //      mutation M {
    //        ObjectCreate(id: "t") {
    //          id
    //        }
    //      }
    //    `,
    //  // VariableValues: variables,
    // }
    // graphql.Do(params)

    // Does not validate input
    params2 := graphql.Params{
        Schema: Schema,
        RequestString: `
      mutation M($input: String!) {
        ObjectCreate(id: $input) {
          id
        }
      }
    `,
        VariableValues: map[string]interface{}{
            "input": "t",
        },
    }
    graphql.Do(params2)
}