引言

在这节中，我们将学习如何将 Ent 连接到 GraphQL。 如果你对 GraphQL 并不熟悉，建议在阅读这篇教程之前先浏览其介绍指南。

克隆代码（可选）

本教程的代码可在 github.com/a8m/ent-graphql-example 获取，每一步过程都打有标签（使用 Git）。 如果你想跳过基础的搭建步骤而从 GraphQL 服务端的初始版本开始，那么你可以使用如下命令克隆仓库并 checkout v0.1.0：

  1. git clone git@github.com:a8m/ent-graphql-example.git
  2. cd ent-graphql-example
  3. git checkout v0.1.0
  4. go run ./cmd/todo/

基础骨架

gqlgen is a framework for easily generating GraphQL servers in Go. In this tutorial, we will review Ent’s official integration with it.

This tutorial begins where the previous one ended (with a working Todo-list schema). We start by creating a simple GraphQL schema for our todo list, then install the 99designs/gqlgen package and configure it. Let’s create a file named todo.graphql and paste the following:

  1. # Maps a Time GraphQL scalar to a Go time.Time struct.
  2. scalar Time
  5. # Define an enumeration type and map it later to Ent enum (Go type).
  6. # https://graphql.org/learn/schema/#enumeration-types
  7. enum Status {
  8.     IN_PROGRESS
  9.     COMPLETED
  10. }
  13. # Define an object type and map it later to the generated Ent model.
  14. # https://graphql.org/learn/schema/#object-types-and-fields
  15. type Todo {
  16.     id: ID!
  17.     createdAt: Time
  18.     status: Status!
  19.     priority: Int!
  20.     text: String!
  21.     parent: Todo
  22.     children: [Todo!]
  23. }
  26. # Define an input type for the mutation below.
  27. # https://graphql.org/learn/schema/#input-types
  28. input TodoInput {
  29.     status: Status! = IN_PROGRESS
  30.     priority: Int
  31.     text: String!
  32.     parent: ID
  33. }
  36. # Define a mutation for creating todos.
  37. # https://graphql.org/learn/queries/#mutations
  38. type Mutation {
  39.     createTodo(todo: TodoInput!): Todo!
  40. }
  43. # Define a query for getting all todos.
  44. type Query {
  45.     todos: [Todo!]
  46. }

Install 99designs/gqlgen:

  1. go get github.com/99designs/gqlgen

The gqlgen package can be configured using a gqlgen.yml file that it automatically loads from the current directory. Let’s add this file. Follow the comments in this file to understand what each config directive means:

  1. # schema tells gqlgen where the GraphQL schema is located.
  2. schema:
  3.   - todo.graphql
  6. # resolver reports where the resolver implementations go.
  7. resolver:
  8.   layout: follow-schema
  9.   dir: .
  12. # gqlgen will search for any type names in the schema in these go packages
  13. # if they match it will use them, otherwise it will generate them.
  16. # autobind tells gqlgen to search for any type names in the GraphQL schema in the
  17. # provided Go package. If they match it will use them, otherwise it will generate new ones.
  18. autobind:
  19.   - todo/ent
  22. # This section declares type mapping between the GraphQL and Go type systems.
  23. models:
  24.   # Defines the ID field as Go 'int'.
  25.   ID:
  26.     model:
  27.       - github.com/99designs/gqlgen/graphql.IntID
  28.   # Map the Status type that was defined in the schema
  29.   Status:
  30.     model:
  31.       - todo/ent/todo.Status

Now, we’re ready to run gqlgen code generation. Execute this command from the root of the project:

  1. go run github.com/99designs/gqlgen

The command above will execute the gqlgen code-generator, and if that finished successfully, your project directory should look like this:

  1. ➜ tree -L 1   
  2. .
  3. ├── ent
  4. ├── example_test.go
  5. ├── generated.go
  6. ├── go.mod
  7. ├── go.sum
  8. ├── gqlgen.yml
  9. ├── models_gen.go
  10. ├── resolver.go
  11. ├── todo.graphql
  12. └── todo.resolvers.go
  15. 1 directories, 9 files

Connect Ent to GQL

After the gqlgen assets were generated, we’re ready to connect Ent to gqlgen and start running our server. This section contains 5 steps, follow them carefully :).

1. Install the GraphQL extension for Ent

  1. go get entgo.io/contrib/entgql

2. Create a new Go file named ent/entc.go, and paste the following content:

  1. // +build ignore
  4. package main
  7. import (
  8.     "log"
  11.     "entgo.io/ent/entc"
  12.     "entgo.io/ent/entc/gen"
  13.     "entgo.io/contrib/entgql"
  14. )
  17. func main() {
  18.     ex, err := entgql.NewExtension()
  19.     if err != nil {
  20.         log.Fatalf("creating entgql extension: %v", err)
  21.     }
  22.     opts := []entc.Option{
  23.         entc.Extensions(ex),
  24.     }
  25.     if err := entc.Generate("./schema", &gen.Config{}, opts...); err != nil {
  26.         log.Fatalf("running ent codegen: %v", err)
  27.     }
  28. }

3. Edit the ent/generate.go file to execute the ent/entc.go file:

  1. package ent
  4. //go:generate go run entc.go

Note that ent/entc.go is ignored using a build tag, and it’s executed by the go generate command through the generate.go file.

4. In order to execute gqlgen through go generate, we create a new generate.go file (in the root of the project) with the following:

  1. package todo
  4. //go:generate go run github.com/99designs/gqlgen

Now, running go generate ./... from the root of the project, triggers both Ent and gqlgen code generation.

  1. go generate ./...

5. gqlgen allows changing the generated Resolver and add additional dependencies to it. Let’s add the ent.Client as a dependency by pasting the following in resolver.go:

  1. package todo
  4. import (
  5.     "todo/ent"
  8.     "github.com/99designs/gqlgen/graphql"
  9. )
  12. // Resolver is the resolver root.
  13. type Resolver struct{ client *ent.Client }
  16. // NewSchema creates a graphql executable schema.
  17. func NewSchema(client *ent.Client) graphql.ExecutableSchema {
  18.     return NewExecutableSchema(Config{
  19.         Resolvers: &Resolver{client},
  20.     })
  21. }

Run the server

We create a new directory cmd/todo and a main.go file with the following code to create the GraphQL server:

  1. package main
  4. import (
  5.     "context"
  6.     "log"
  7.     "net/http"
  10.     "todo"
  11.     "todo/ent"
  12.     "todo/ent/migrate"
  15.     "entgo.io/ent/dialect"
  16.     "github.com/99designs/gqlgen/graphql/handler"
  17.     "github.com/99designs/gqlgen/graphql/playground"
  20.     _ "github.com/mattn/go-sqlite3"
  21. )
  24. func main() {
  25.     // Create ent.Client and run the schema migration.
  26.     client, err := ent.Open(dialect.SQLite, "file:ent?mode=memory&cache=shared&_fk=1")
  27.     if err != nil {
  28.         log.Fatal("opening ent client", err)
  29.     }
  30.     if err := client.Schema.Create(
  31.         context.Background(),
  32.         migrate.WithGlobalUniqueID(true),
  33.     ); err != nil {
  34.         log.Fatal("opening ent client", err)
  35.     }
  38.     // Configure the server and start listening on :8081.
  39.     srv := handler.NewDefaultServer(todo.NewSchema(client))
  40.     http.Handle("/",
  41.         playground.Handler("Todo", "/query"),
  42.     )
  43.     http.Handle("/query", srv)
  44.     log.Println("listening on :8081")
  45.     if err := http.ListenAndServe(":8081", nil); err != nil {
  46.         log.Fatal("http server terminated", err)
  47.     }
  48. }

Run the server using the command below, and open localhost:8081:

  1. go run ./cmd/todo

You should see the interactive playground:

tutorial-todo-playground

If you’re having troubles with getting the playground to run, go to first section and clone the example repository.

Query Todos

If we try to query our todo list, we’ll get an error as the resolver method is not yet implemented. Let’s implement the resolver by replacing the Todos implementation in the query resolver:

  1. func (r *queryResolver) Todos(ctx context.Context) ([]*ent.Todo, error) {
  2. -   panic(fmt.Errorf("not implemented"))
  3. +   return r.client.Todo.Query().All(ctx)
  4. }

Then, running this GraphQL query should return an empty todo list:

  1. query AllTodos {
  2.     todos {
  3.         id
  4.     }
  5. }
  8. # Output: { "data": { "todos": [] } }

Create a Todo

Same as before, if we try to create a todo item in GraphQL, we’ll get an error as the resolver is not yet implemented. Let’s implement the resolver by changing the CreateTodo implementation in the mutation resolver:

  1. func (r *mutationResolver) CreateTodo(ctx context.Context, todo TodoInput) (*ent.Todo, error) {
  2.     return r.client.Todo.Create().
  3.         SetText(todo.Text).
  4.         SetStatus(todo.Status).
  5.         SetNillablePriority(todo.Priority). // Set the "priority" field if provided.
  6.         SetNillableParentID(todo.Parent).   // Set the "parent_id" field if provided.
  7.         Save(ctx)
  8. }

Now, creating a todo item should work:

  1. mutation CreateTodo($todo: TodoInput!) {
  2.     createTodo(todo: $todo) {
  3.         id
  4.         text
  5.         createdAt
  6.         priority
  7.         parent {
  8.             id
  9.         }
  10.     }
  11. }
  14. # Query Variables: { "todo": { "text": "Create GraphQL Example", "status": "IN_PROGRESS", "priority": 1 } }
  15. # Output: { "data": { "createTodo": { "id": "2", "text": "Create GraphQL Example", "createdAt": "2021-03-10T15:02:18+02:00", "priority": 1, "parent": null } } }

If you’re having troubles with getting this example to work, go to first section and clone the example repository.

Please continue to the next section where we explain how to implement the Relay Node Interface and learn how Ent automatically supports this.