// Extracts the root type of the operation from the schema. func getOperationRootType(schema Schema, operation ast.Definition) (*Object, error) { if operation == nil { return nil, errors.New("Can only execute queries and mutations") } switch operation.GetOperation() { case ast.OperationTypeQuery: return schema.QueryType(), nil case ast.OperationTypeMutation: mutationType := schema.MutationType() if mutationType.PrivateName == "" { return nil, gqlerrors.NewError( "Schema is not configured for mutations", []ast.Node{operation}, "", nil, []int{}, nil, ) } return mutationType, nil case ast.OperationTypeSubscription: subscriptionType := schema.SubscriptionType() if subscriptionType.PrivateName == "" { return nil, gqlerrors.NewError( "Schema is not configured for subscriptions", []ast.Node{operation}, "", nil, []int{}, nil, ) } return subscriptionType, nil default: return nil, gqlerrors.NewError( "Can only execute queries, mutations and subscription", []ast.Node{operation}, "", nil, []int{}, nil, ) } }
func NewLocatedError(err interface{}, nodes []ast.Node) *gqlerrors.Error { var origError error message := "An unknown error occurred." if err, ok := err.(error); ok { message = err.Error() origError = err } if err, ok := err.(string); ok { message = err origError = errors.New(err) } stack := message return gqlerrors.NewError( message, nodes, stack, nil, []int{}, origError, ) }
// Given a variable definition, and any value of input, return a value which // adheres to the variable definition, or throw an error. func getVariableValue(schema Schema, definitionAST *ast.VariableDefinition, input interface{}) (interface{}, error) { ttype, err := typeFromAST(schema, definitionAST.Type) if err != nil { return nil, err } variable := definitionAST.Variable if ttype == nil || !IsInputType(ttype) { return "", gqlerrors.NewError( fmt.Sprintf(`Variable "$%v" expected value of type `+ `"%v" which cannot be used as an input type.`, variable.Name.Value, printer.Print(definitionAST.Type)), []ast.Node{definitionAST}, "", nil, []int{}, nil, ) } isValid, messages := isValidInputValue(input, ttype) if isValid { if isNullish(input) { defaultValue := definitionAST.DefaultValue if defaultValue != nil { variables := map[string]interface{}{} val := valueFromAST(defaultValue, ttype, variables) return val, nil } } return coerceValue(ttype, input), nil } if isNullish(input) { return "", gqlerrors.NewError( fmt.Sprintf(`Variable "$%v" of required type `+ `"%v" was not provided.`, variable.Name.Value, printer.Print(definitionAST.Type)), []ast.Node{definitionAST}, "", nil, []int{}, nil, ) } // convert input interface into string for error message inputStr := "" b, err := json.Marshal(input) if err == nil { inputStr = string(b) } messagesStr := "" if len(messages) > 0 { messagesStr = "\n" + strings.Join(messages, "\n") } return "", gqlerrors.NewError( fmt.Sprintf(`Variable "$%v" got invalid value `+ `%v.%v`, variable.Name.Value, inputStr, messagesStr), []ast.Node{definitionAST}, "", nil, []int{}, nil, ) }