当前位置：首页 > 文章列表 > Golang > Go问答 > 在 go-graphql 中设置变量“$address”为非输入类型“String!”是不允许的

在 go-graphql 中设置变量“$address”为非输入类型“String!”是不允许的

来源：stackoverflow 2024-03-20 14:18:30 0浏览收藏

在 Go 中使用 graphql-go 库时，为 GraphQL 查询设置查询参数可能导致错误。当直接传递参数时，查询可以正常工作，但使用查询参数时却会失败。这可能是由于架构中重复的类型名称造成的。为了解决此问题，建议重命名其中一个重复的类型名称，以消除歧义。

问题内容

我已经使用 graphql-go 库在 go 中成功设置了 graphql 服务器。但是，当我在进行查询时传递查询参数时，似乎出现错误。因此，我有一个名为 emails 的查询，它以 address 作为参数，并查询数据库以返回与给定 address 关联的所有电子邮件的结果。当我直接传递 address 参数时，一切似乎都运行良好，正如您从此图中看到的那样：

但是，当我向它传递查询参数时，它似乎不起作用，如下所示：

我不认为这两个语句应该给出相同的结果。然而，情况似乎并非如此。有人可以帮助我理解为什么我会收到这些错误吗？这是我的代码

package main

import (
    "log"
    "net/http"

    "github.com/graphql-go/graphql"
    "github.com/graphql-go/handler"

    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/credentials"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/dynamodb"
    "github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute"
)

var sess, _ = session.NewSession()

// Email - Used to represent a single email object stored in
// dynamodb. Fields 'attachments', 'body-html', 'stripped-html' and
// 'stripped-text' may be empty.
type Email struct {
    To           string   `json:"to"`
    Recipients   []string `json:"recipients"`
    Token        string   `json:"token"`
    Sender       string   `json:"sender"`
    Subject      string   `json:"subject"`
    Timestamp    string   `json:"timestamp"`
    Attachments  []string `json:"attachments"`
    Mime         string   `json:"mime"`
    BodyPlain    string   `json:"body_plain"`
    BodyHTML     string   `json:"body_html"`
    StrippedText string   `json:"stripped_text"`
    StrippedHTML string   `json:"stripped_html"`
}

// emailType - a new graphql object representing a single email
var emailType = graphql.NewObject(graphql.ObjectConfig{
    Name: "Email",
    Fields: graphql.Fields{
        "to": &graphql.Field{
            Type: graphql.String,
        },
        "recipients": &graphql.Field{
            Type: graphql.NewList(graphql.String),
        },
        "token": &graphql.Field{
            Type: graphql.String,
        },
        "sender": &graphql.Field{
            Type: graphql.String,
        },
        "subject": &graphql.Field{
            Type: graphql.String,
        },
        "attachments": &graphql.Field{
            Type: graphql.NewList(graphql.String),
        },
        "timestamp": &graphql.Field{
            Type: graphql.String,
        },
        "mime": &graphql.Field{
            Type: graphql.String,
        },
        "body_plain": &graphql.Field{
            Type: graphql.String,
        },
        "body_html": &graphql.Field{
            Type: graphql.String,
        },
        "stripped_text": &graphql.Field{
            Type: graphql.String,
        },
        "stripped_html": &graphql.Field{
            Type: graphql.String,
        },
    },
})

// emailType - a new graphql object representing a deleted email.
var deleteEmailType = graphql.NewObject(graphql.ObjectConfig{
    Name: "Email",
    Fields: graphql.Fields{
        "to": &graphql.Field{
            Type: graphql.String,
        },
        "token": &graphql.Field{
            Type: graphql.String,
        },
    },
})

func disableCors(h http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Access-Control-Allow-Origin", "*")
        w.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE")
        w.Header().Set("Access-Control-Allow-Headers", "Accept, Authorization, Content-Type, Content-Length, Accept-Encoding")

        // I added this for another handler of mine,
        // but I do not think this is necessary for GraphQL's handler
        if r.Method == "OPTIONS" {
            w.Header().Set("Access-Control-Max-Age", "86400")
            w.WriteHeader(http.StatusOK)
            return
        }

        h.ServeHTTP(w, r)
    })
}

func main() {
    // configures the rootQuery for the graphQL API
    rootQuery := graphql.NewObject(graphql.ObjectConfig{
        Name: "Query",
        Fields: graphql.Fields{
            "emails": &graphql.Field{
                Type: graphql.NewList(emailType),
                Args: graphql.FieldConfigArgument{
                    "address": &graphql.ArgumentConfig{
                        Type: graphql.String,
                    },
                },
                Resolve: func(params graphql.ResolveParams) (interface{}, error) {
                    address := params.Args["address"].(string)
                    svc := dynamodb.New(sess)
                    result, err := svc.Query(&dynamodb.QueryInput{
                        TableName: aws.String("emails_db"),
                        KeyConditions: map[string]*dynamodb.Condition{
                            "to": {
                                ComparisonOperator: aws.String("EQ"),
                                AttributeValueList: []*dynamodb.AttributeValue{
                                    {
                                        S: aws.String(address),
                                    },
                                },
                            },
                        },
                    })
                    if err != nil {
                        return nil, nil
                    }

                    // unmarshalls all the emails to recs
                    recs := []Email{}
                    err = dynamodbattribute.UnmarshalListOfMaps(result.Items, &recs)
                    if err != nil {
                        return nil, nil
                    }
                    return recs, nil
                },
            },
        },
    })

    // configures the rootMutation for the graphQL API
    rootMutation := graphql.NewObject(graphql.ObjectConfig{
        Name: "Mutation",
        Fields: graphql.Fields{
            "email": &graphql.Field{
                Type: deleteEmailType,
                Args: graphql.FieldConfigArgument{
                    "address": &graphql.ArgumentConfig{
                        Type: graphql.NewNonNull(graphql.String),
                    },
                    "token": &graphql.ArgumentConfig{
                        Type: graphql.NewNonNull(graphql.String),
                    },
                },
                Resolve: func(params graphql.ResolveParams) (interface{}, error) {
                    address := params.Args["address"].(string)
                    token := params.Args["token"].(string)
                    svc := dynamodb.New(sess)
                    _, err := svc.DeleteItem(&dynamodb.DeleteItemInput{
                        TableName: aws.String("emails_db"),
                        Key: map[string]*dynamodb.AttributeValue{
                            "to": {
                                S: aws.String(address),
                            },
                            "token": {
                                S: aws.String(token),
                            },
                        },
                    })
                    if err != nil {
                        return nil, err
                    }

                    // unmarshalls all the emails to recs
                    rec := Email{To: address, Token: token}
                    return rec, nil
                },
            },
        },
    })

    // configures routes
    schema, _ := graphql.NewSchema(graphql.SchemaConfig{
        Mutation: rootMutation,
        Query:    rootQuery,
    })
    h := handler.New(&handler.Config{
        Schema:   &schema,
        Pretty:   true,
        GraphiQL: true,
    })
    http.Handle("/graphql", disableCors(h))
    log.Fatal(http.ListenAndServe(":80", nil))
}