Setting Up

This guide is intended for first-time users who want instructions on how to set up an Ent project from scratch. Before we get started, make sure you have the following prerequisites installed on your machine.

Prerequisites

After installing these dependencies, create a directory for the project and initialize a Go module:

  1. mkdir todo
  2. cd $_
  3. go mod init todo

Installation

Run the following Go commands to install Ent, and tell it to initialize the project structure along with a Todo schema.

  1. go get -d entgo.io/ent/cmd/ent
  1. go run -mod=mod entgo.io/ent/cmd/ent new Todo

After installing Ent and running ent new, your project directory should look like this:

  1. .
  2. ├── ent
  3. │   ├── generate.go
  4. │   └── schema
  5. │       └── todo.go
  6. ├── go.mod
  7. └── go.sum

The ent directory holds the generated assets (see the next section), and the ent/schema directory contains your entity schemas.

Code Generation

When we ran ent new Todo above, a schema named Todo was created in the todo.go file under thetodo/ent/schema/ directory:

  1. package schema
  3. import "entgo.io/ent"
  5. // Todo holds the schema definition for the Todo entity.
  6. type Todo struct {
  7.     ent.Schema
  8. }
  10. // Fields of the Todo.
  11. func (Todo) Fields() []ent.Field {
  12.     return nil
  13. }
  15. // Edges of the Todo.
  16. func (Todo) Edges() []ent.Edge {
  17.     return nil
  18. }

As you can see, initially, the schema has no fields or edges defined. Let’s run the command for generating assets to interact with the Todo entity:

  1. go generate ./ent

Create a Test Case

Running go generate ./ent invoked Ent’s automatic code generation tool, which uses the schemas we define in our schema package to generate the actual Go code which we will now use to interact with a database. At this stage, you can find under ./ent/client.go, client code that is capable of querying and mutating the Todo entities. Let’s create a testable example to use this. We’ll use SQLite in this test-case for testing Ent.

  1. go get github.com/mattn/go-sqlite3
  2. touch example_test.go

Paste the following code in example_test.go that instantiates an ent.Client and automatically creates all schema resources in the database (tables, columns, etc).

  1. package todo
  3. import (
  4.     "context"
  5.     "log"
  6.     "todo/ent"
  8.     "entgo.io/ent/dialect"
  9.     _ "github.com/mattn/go-sqlite3"
  10. )
  12. func Example_Todo() {
  13.     // Create an ent.Client with in-memory SQLite database.
  14.     client, err := ent.Open(dialect.SQLite, "file:ent?mode=memory&cache=shared&_fk=1")
  15.     if err != nil {
  16.         log.Fatalf("failed opening connection to sqlite: %v", err)
  17.     }
  18.     defer client.Close()
  19.     ctx := context.Background()
  20.     // Run the automatic migration tool to create all schema resources.
  21.     if err := client.Schema.Create(ctx); err != nil {
  22.         log.Fatalf("failed creating schema resources: %v", err)
  23.     }
  24.     // Output:
  25. }

Then, run go test to verify that everything works as expected.

  1. go test

After setting up our project, we’re ready to create our Todo list.