Blog | ent

Announcing the "Schema Import Initiative" and protoc-gen-ent

4 במאי 2021 · 3 min read

Migrating to a new ORM is not an easy process, and the transition cost can be prohibitive to many organizations. As much as we developers are enamoured by "Shiny New Things", the truth is that we rarely get a chance to work on a truly "green-field" project. Most of our careers, we operate in contexts where many technical and business constraints (a.k.a legacy systems) dictate and limit our options for moving forward. Developers of new technologies that want to succeed must offer interoperability capability and integration paths to help organizations seamlessly transition to a new way of solving an existing problem.

To help lower the cost of transitioning to Ent (or simply experimenting with it), we have started the "Schema Import Initiative" to help support many use cases for generating Ent schemas from external resources. The centrepiece of this effort is the schemast package (source code, docs) which enables developers to easily write programs that generate and manipulate Ent schemas. Using this package, developers can program in a high-level API, relieving them from worrying about code parsing and AST manipulations.

Protobuf Import Support

The first project to use this new API, is protoc-gen-ent, a protoc plugin to generate Ent schemas from .proto files (docs). Organizations that have existing schemas defined in Protobuf can use this tool to generate Ent code automatically. For example, taking a simple message definition:

syntax = "proto3";

package entpb;

option go_package = "github.com/yourorg/project/ent/proto/entpb";

message User {
  string name = 1;
  string email_address = 2;
}

And setting the ent.schema.gen option to true:

syntax = "proto3";

package entpb;

+import "options/opts.proto";

option go_package = "github.com/yourorg/project/ent/proto/entpb";  

message User {
+  option (ent.schema).gen = true; // <-- tell protoc-gen-ent you want to generate a schema from this message
  string name = 1;
  string email_address = 2;
}

Developers can invoke the standard protoc (protobuf compiler) command to use this plugin:

protoc -I=proto/ --ent_out=. --ent_opt=schemadir=./schema proto/entpb/user.proto

To generate Ent schemas from these definitions:

package schema

import (
    "entgo.io/ent"
    "entgo.io/ent/schema/field"
)

type User struct {
    ent.Schema
}

func (User) Fields() []ent.Field {
    return []ent.Field{field.String("name"), field.String("email_address")}
}
func (User) Edges() []ent.Edge {
    return nil
}

To start using protoc-gen-ent today, and read about all of the different configuration options, head over to the documentation!

Join the Schema Import Initiative

Do you have schemas defined elsewhere that you would like to automatically import in to Ent? With the schemast package, it is easier than ever to write the tool that you need to do that. Not sure how to start? Want to collaborate with the community in planning and building out your idea? Reach out to our great community via our Discord server, Slack channel or start a discussion on GitHub!

For more Ent news and updates:

Subscribe to our Newsletter
Follow us on Twitter
Join us on #ent on the Gophers Slack
Join us on the Ent Discord Server

Generate a fully-working Go gRPC server in two minutes with Ent

18 במרץ 2021 · 11 min read

Rotem Tamir

ent + gRPC

Introduction

Having entity schemas defined in a central, language-neutral format has many benefits as the scale of software engineering organizations increase. To do this, many organizations use Protocol Buffers as their interface definition language (IDL). In addition, gRPC, a Protobuf-based RPC framework modeled after Google's internal Stubby is becoming increasingly popular due to its efficiency and code-generation capabilities.

Being an IDL, gRPC does not prescribe any specific guidelines on implementing the data access layer so implementations vary greatly. Ent is a natural candidate for building the data access layer in any Go application and so there is great potential in integrating the two technologies together.

Today we announce an experimental version of entproto, a Go package, and a command-line tool to add Protobuf and gRPC support for ent users. With entproto, developers can set up a fully working CRUD gRPC server in a few minutes. In this post, we will show exactly how to do just that.

Setting Up

The final version of this tutorial is available on GitHub, you can clone it if you prefer following along that way.

Let's start by initializing a new Go module for our project:

mkdir ent-grpc-example
cd ent-grpc-example
go mod init ent-grpc-example

Next we use go run to invoke the ent code generator to initialize a schema:

go run -mod=mod entgo.io/ent/cmd/ent new User

Our directory should now look like:

.
├── ent
│   ├── generate.go
│   └── schema
│       └── user.go
├── go.mod
└── go.sum

Next, let's add the entproto package to our project:

go get -u entgo.io/contrib/entproto

Next, we will define the schema for the User entity. Open ent/schema/user.go and edit:

package schema

import (
    "entgo.io/ent"
    "entgo.io/ent/schema"
)

// User holds the schema definition for the User entity.
type User struct {
    ent.Schema
}

// Fields of the User.
func (User) Fields() []ent.Field {
    return []ent.Field{
        field.String("name").
            Unique(),
        field.String("email_address").
            Unique(),
    }
}

In this step, we added two unique fields to our User entity: name and email_address. The ent.Schema is just the definition of the schema, to create usable production code from it we need to run Ent's code generation tool on it. Run:

go generate ./...

Notice the a bunch of new files were created from our schema definition now:

├── ent
│   ├── client.go
│   ├── config.go
// .... many more
│   ├── user
│   ├── user.go
│   ├── user_create.go
│   ├── user_delete.go
│   ├── user_query.go
│   └── user_update.go
├── go.mod
└── go.sum

At this point, we can open a connection to a database, run a migration to create the users table, and start reading and writing data to it. This is covered on the Setup Tutorial, so let's cut to the chase and learn about generating Protobuf definitions and gRPC servers from our schema.

Generating Go Protobufs with `entproto`

As ent and Protobuf schemas are not identical, we must supply some annotations on our schema to help entproto figure out exactly how to generate Protobuf definitions (called "Messages" in protobuf lingo).

The first thing we need to do is to add an entproto.Message() annotation. This is our opt-in to Protobuf schema generation, we don't necessarily want to generate proto messages or gRPC service definitions from all of our schema entities, and this annotation gives us that control. To add it, append to ent/schema/user.go:

func (User) Annotations() []schema.Annotation {
    return []schema.Annotation{
        entproto.Message(),
    }
}

Next, we need to annotate each field and assign it a field number. Recall that when defining a protobuf message type, each field must be assigned a unique number. To do that, we add an entproto.Field annotation on each field. Update the Fields in ent/schema/user.go:

// Fields of the User.
func (User) Fields() []ent.Field {
    return []ent.Field{
        field.String("name").
            Unique().
            Annotations(
                entproto.Field(2),
            ),
        field.String("email_address").
            Unique().
            Annotations(
                entproto.Field(3),
            ),
    }
}

Notice that we did not start our field numbers from 1, this is because ent implicitly creates the ID field for the entity, and that field is automatically assigned the number 1. We can now generate our protobuf message type definitions. To do that, we will add to ent/generate.go a go:generate directive that invokes the entproto command-line tool. It should now look like this:

package ent

//go:generate go run -mod=mod entgo.io/ent/cmd/ent generate ./schema
//go:generate go run -mod=mod entgo.io/contrib/entproto/cmd/entproto -path ./schema

Let's re-generate our code:

go generate ./...

Observe that a new directory was created which will contain all protobuf related generated code: ent/proto. It now contains:

ent/proto
└── entpb
    ├── entpb.proto
    └── generate.go

Two files were created. Let's look at their contents:

// Code generated by entproto. DO NOT EDIT.
syntax = "proto3";

package entpb;

option go_package = "ent-grpc-example/ent/proto/entpb";

message User {
  int32 id = 1;

  string user_name = 2;

  string email_address = 3;
}

Nice! A new .proto file containing a message type definition that maps to our User schema was created!

package entpb
//go:generate protoc -I=.. --go_out=.. --go-grpc_out=.. --go_opt=paths=source_relative --go-grpc_opt=paths=source_relative --entgrpc_out=.. --entgrpc_opt=paths=source_relative,schema_path=../../schema entpb/entpb.proto

A new generate.go file was created with an invocation to protoc, the protobuf code generator instructing it how to generate Go code from our .proto file. For this command to work, we must first install protoc as well as 3 protobuf plugins: protoc-gen-go (which generates Go Protobuf structs), protoc-gen-go-grpc (which generates Go gRPC service interfaces and clients), and protoc-gen-entgrpc (which generates an implementation of the service interface). If you do not have these installed, please follow these directions:

protoc installation
protoc-gen-go + protoc-gen-go-grpc installation
Run go get -u entgo.io/contrib/entproto/cmd/protoc-gen-entgrpc to install protoc-gen-entgrpc

After installing these dependencies, we can re-run code-generation:

go generate ./...

Observe that a new file named ent/proto/entpb/entpb.pb.go was created which contains the generated Go structs for our entities.

Let's write a test that uses it to make sure everything is wired correctly. Create a new file named pb_test.go and write:

package main

import (
    "testing"

    "ent-grpc-example/ent/proto/entpb"
)

func TestUserProto(t *testing.T) {
    user := entpb.User{
        Name:     "rotemtam",
        EmailAddress: "rotemtam@example.com",
    }
    if user.GetName() != "rotemtam" {
        t.Fatal("expected user name to be rotemtam")
    }
    if user.GetEmailAddress() != "rotemtam@example.com" {
        t.Fatal("expected email address to be rotemtam@example.com")
    }
}

To run it:

go get -u./... # install deps of the generated package
go test ./...

Hooray! The test passes. We have successfully generated working Go Protobuf structs from our Ent schema. Next, let's see how to automatically generate a working CRUD gRPC server from our schema.

Generating a Fully Working gRPC Server from our Schema

Having Protobuf structs generated from our ent.Schema can be useful, but what we're really interested in is getting an actual server that can create, read, update, and delete entities from an actual database. To do that, we need to update just one line of code! When we annotate a schema with entproto.Service, we tell the entproto code-gen that we are interested in generating a gRPC service definition, from the protoc-gen-entgrpc will read our definition and generate a service implementation. Edit ent/schema/user.go and modify the schema's Annotations:

func (User) Annotations() []schema.Annotation {
    return []schema.Annotation{
        entproto.Message(),
+       entproto.Service(), // <-- add this
    }
}

Now re-run code-generation:

go generate ./...

Observe some interesting changes in ent/proto/entpb:

ent/proto/entpb
├── entpb.pb.go
├── entpb.proto
├── entpb_grpc.pb.go
├── entpb_user_service.go
└── generate.go

First, entproto added a service definition to entpb.proto:

service UserService {
  rpc Create ( CreateUserRequest ) returns ( User );

  rpc Get ( GetUserRequest ) returns ( User );

  rpc Update ( UpdateUserRequest ) returns ( User );

  rpc Delete ( DeleteUserRequest ) returns ( google.protobuf.Empty );
}

In addition, two new files were created. The first, ent_grpc.pb.go, contains the gRPC client stub and the interface definition. If you open the file, you will find in it (among many other things):

// UserServiceClient is the client API for UserService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type UserServiceClient interface {
    Create(ctx context.Context, in *CreateUserRequest, opts ...grpc.CallOption) (*User, error)
    Get(ctx context.Context, in *GetUserRequest, opts ...grpc.CallOption) (*User, error)
    Update(ctx context.Context, in *UpdateUserRequest, opts ...grpc.CallOption) (*User, error)
    Delete(ctx context.Context, in *DeleteUserRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

The second file, entpub_user_service.go contains a generated implementation for this interface. For example, an implementation for the Get method:

// Get implements UserServiceServer.Get
func (svc *UserService) Get(ctx context.Context, req *GetUserRequest) (*User, error) {
    get, err := svc.client.User.Get(ctx, int(req.GetId()))
    switch {
    case err == nil:
        return toProtoUser(get), nil
    case ent.IsNotFound(err):
        return nil, status.Errorf(codes.NotFound, "not found: %s", err)
    default:
        return nil, status.Errorf(codes.Internal, "internal error: %s", err)
    }
}

Not bad! Next, let's create a gRPC server that can serve requests to our service.

Creating the Server

Create a new file cmd/server/main.go and write:

package main

import (
    "context"
    "log"
    "net"

    _ "github.com/mattn/go-sqlite3"
    "ent-grpc-example/ent"
    "ent-grpc-example/ent/proto/entpb"
    "google.golang.org/grpc"
)

func main() {
    // Initialize an ent client.
    client, err := ent.Open("sqlite3", "file:ent?mode=memory&cache=shared&_fk=1")
    if err != nil {
        log.Fatalf("failed opening connection to sqlite: %v", err)
    }
    defer client.Close()

    // Run the migration tool (creating tables, etc).
    if err := client.Schema.Create(context.Background()); err != nil {
        log.Fatalf("failed creating schema resources: %v", err)
    }

    // Initialize the generated User service.
    svc := entpb.NewUserService(client)

    // Create a new gRPC server (you can wire multiple services to a single server).
    server := grpc.NewServer()

    // Register the User service with the server.
    entpb.RegisterUserServiceServer(server, svc)

    // Open port 5000 for listening to traffic.
    lis, err := net.Listen("tcp", ":5000")
    if err != nil {
        log.Fatalf("failed listening: %s", err)
    }

    // Listen for traffic indefinitely.
    if err := server.Serve(lis); err != nil {
        log.Fatalf("server ended: %s", err)
    }
}

Notice that we added an import of github.com/mattn/go-sqlite3, so we need to add it to our module:

go get -u github.com/mattn/go-sqlite3

Next, let's run the server, while we write a client that will communicate with it:

go run -mod=mod ./cmd/server

Creating the Client

Let's create a simple client that will make some calls to our server. Create a new file named cmd/client/main.go and write:

package main

import (
    "context"
    "fmt"
    "log"
    "math/rand"
    "time"

    "ent-grpc-example/ent/proto/entpb"
    "google.golang.org/grpc"
    "google.golang.org/grpc/status"
)

func main() {
    rand.Seed(time.Now().UnixNano())

    // Open a connection to the server.
    conn, err := grpc.Dial(":5000", grpc.WithInsecure())
    if err != nil {
        log.Fatalf("failed connecting to server: %s", err)
    }
    defer conn.Close()

    // Create a User service Client on the connection.
    client := entpb.NewUserServiceClient(conn)

    // Ask the server to create a random User.
    ctx := context.Background()
    user := randomUser()
    created, err := client.Create(ctx, &entpb.CreateUserRequest{
        User: user,
    })
    if err != nil {
        se, _ := status.FromError(err)
        log.Fatalf("failed creating user: status=%s message=%s", se.Code(), se.Message())
    }
    log.Printf("user created with id: %d", created.Id)

    // On a separate RPC invocation, retrieve the user we saved previously.
    get, err := client.Get(ctx, &entpb.GetUserRequest{
        Id: created.Id,
    })
    if err != nil {
        se, _ := status.FromError(err)
        log.Fatalf("failed retrieving user: status=%s message=%s", se.Code(), se.Message())
    }
    log.Printf("retrieved user with id=%d: %v", get.Id, get)
}

func randomUser() *entpb.User {
    return &entpb.User{
        Name:         fmt.Sprintf("user_%d", rand.Int()),
        EmailAddress: fmt.Sprintf("user_%d@example.com", rand.Int()),
    }
}

Our client creates a connection to port 5000, where our server is listening, then issues a Create request to create a new user, and then issues a second Get request to retrieve it from the database. Let's run our client code:

go run ./cmd/client

Observe the output:

2021/03/18 10:42:58 user created with id: 1
2021/03/18 10:42:58 retrieved user with id=1: id:1 name:"user_730811260095307266" email_address:"user_7338662242574055998@example.com"

Amazing! With a few annotations on our schema, we used the super-powers of code generation to create a working gRPC server in no time!

Caveats and Limitations

entproto is still experimental stage and lacks some basic functionality. For example, many applications will probably want a List or Find method on their service, but these are not yet supported. In addition, some other issues we plan to tackle in the near future:

Currently only "unique" edges are supported (O2O, O2M).
The generated "mutating" methods (Create/Update) currently set all fields, disregarding zero/null values and field nullability.
All fields are copied from the gRPC request to the ent client, support for configuring some fields to be unsettable via the service by adding a field/edge annotation is also planned.

Next Steps

We believe that ent + gRPC can be a great way to build server applications in Go. For example, to set granular access control to the entities managed by our application, developers can already use Privacy Policies that work out-of-the-box with the gRPC integration. To run any arbitrary Go code on the different lifecycle events of entities, developers can utilize custom Hooks.

Do you want to build gRPC servers with ent? If you want some help setting up or want the integration to support your use case, please reach out to us via our Discussions Page on GitHub or in the #ent channel on the Gophers Slack or our Discord server.

For more Ent news and updates:

Subscribe to our Newsletter
Follow us on Twitter
Join us on #ent on the Gophers Slack
Join us on the Ent Discord Server

Announcing Edge-field Support in v0.7.0

12 במרץ 2021 · 5 min read

Rotem Tamir

Over the past few months, there has been much discussion in the Ent project issues about adding support for the retrieval of the foreign key field when retrieving entities with One-to-One or One-to-Many edges. We are happy to announce that as of v0.7.0 ent supports this feature.

Before Edge-field Support

Prior to merging this branch, a user that wanted to retrieve the foreign-key field for an entity needed to use eager-loading. Suppose our schema looked like this:

// ent/schema/user.go:

// User holds the schema definition for the User entity.
type User struct {
    ent.Schema
}

// Fields of the User.
func (User) Fields() []ent.Field {
    return []ent.Field{
        field.String("name").
            Unique().
            NotEmpty(),
    }
}

// Edges of the User.
func (User) Edges() []ent.Edge {
    return []ent.Edge{
        edge.From("pets", Pet.Type).
            Ref("owner"),
    }
}

// ent/schema/pet.go

// Pet holds the schema definition for the Pet entity.
type Pet struct {
    ent.Schema
}

// Fields of the Pet.
func (Pet) Fields() []ent.Field {
    return []ent.Field{
        field.String("name").
            NotEmpty(),
    }
}

// Edges of the Pet.
func (Pet) Edges() []ent.Edge {
    return []ent.Edge{
        edge.To("owner", User.Type).
            Unique().
            Required(),
    }
}

The schema describes two related entities: User and Pet, with a One-to-Many edge between them: a user can own many pets and a pet can have one owner.

When retrieving pets from the data storage, it is common for developers to want to access the foreign-key field on the pet. However, because this field is created implicitly from the owner edge it was automatically accessible when retrieving an entity. To retrieve this from the storage a developer needed to do something like:

func Test(t *testing.T) {
    ctx := context.Background()
    c := enttest.Open(t, dialect.SQLite, "file:ent?mode=memory&cache=shared&_fk=1")
    defer c.Close()

    // Create the User
    u := c.User.Create().
        SetUserName("rotem").
        SaveX(ctx)

    // Create the Pet
    p := c.Pet.
        Create().
        SetOwner(u). // Associate with the user
        SetName("donut").
        SaveX(ctx)

    petWithOwnerId := c.Pet.Query().
        Where(pet.ID(p.ID)).
        WithOwner(func(query *ent.UserQuery) {
            query.Select(user.FieldID)
        }).
        OnlyX(ctx)
    fmt.Println(petWithOwnerId.Edges.Owner.ID)
    // Output: 1
}

Aside from being very verbose, retrieving the pet with the owner this way was inefficient in-terms of database queries. If we execute the query with the .Debug() we can see the DB queries ent generates to satisfy this call:

SELECT DISTINCT `pets`.`id`, `pets`.`name`, `pets`.`pet_owner` FROM `pets` WHERE `pets`.`id` = ? LIMIT 2 
SELECT DISTINCT `users`.`id` FROM `users` WHERE `users`.`id` IN (?)

In this example, Ent first retrieves the Pet with an ID of 1, then redundantly fetches the id field from the users table for users with an ID of 1.

With Edge-field Support

Edge-field support greatly simplifies and improves the efficiency of this flow. With this feature, developers can define the foreign key field as part of the schemas Fields(), and by using the .Field(..) modifier on the edge definition instruct Ent to expose and map the foreign column to this field. So, in our example schema, we would modify it to be:

// user.go stays the same

// pet.go
// Fields of the Pet.
func (Pet) Fields() []ent.Field {
    return []ent.Field{
        field.String("name").
            NotEmpty(),
        field.Int("owner_id"), // <-- explicitly add the field we want to contain the FK
    }
}

// Edges of the Pet.
func (Pet) Edges() []ent.Edge {
    return []ent.Edge{
        edge.To("owner", User.Type).
            Field("owner_id"). // <-- tell ent which field holds the reference to the owner
            Unique().
            Required(),
    }
}

In order to update our client code we need to re-run code generation:

go generate ./...

We can now modify our query to be much simpler:

func Test(t *testing.T) {
    ctx := context.Background()
    c := enttest.Open(t, dialect.SQLite, "file:ent?mode=memory&cache=shared&_fk=1")
    defer c.Close()

    u := c.User.Create().
        SetUserName("rotem").
        SaveX(ctx)

    p := c.Pet.Create().
        SetOwner(u).
        SetName("donut").
        SaveX(ctx)

    petWithOwnerId := c.Pet.GetX(ctx, p.ID) // <-- Simply retrieve the Pet

    fmt.Println(petWithOwnerId.OwnerID)
    // Output: 1
}

Running with the .Debug() modifier we can see that the DB queries make more sense now:

SELECT DISTINCT `pets`.`id`, `pets`.`name`, `pets`.`owner_id` FROM `pets` WHERE `pets`.`id` = ? LIMIT 2

Hooray 🎉!

Migrating Existing Schemas to Edge Fields

If you are already using Ent with an existing schema, you may already have O2M relations whose foreign-key columns already exist in your database. Depending on how you configured your schema, chances are that they may be stored in a column by a different name than the field you are now adding. For instance, you want to create an owner_id field, but Ent auto-created the column foreign-key column as pet_owner.

To check what column name Ent is using for this field you can look in the ./ent/migrate/schema.go file:

PetsColumns = []*schema.Column{
    {Name: "id", Type: field.TypeInt, Increment: true},
    {Name: "name", Type: field.TypeString},
    {Name: "pet_owner", Type: field.TypeInt, Nullable: true}, // <-- this is our FK
}

To allow for a smooth migration, you must explicitly tell Ent to keep using the existing column name. You can do this by using the StorageKey modifier (either on the field or on the edge). For example:

// In schema/pet.go:

// Fields of the Pet.
func (Pet) Fields() []ent.Field {
    return []ent.Field{
        field.String("name").
            NotEmpty(),
        field.Int("owner_id").
            StorageKey("pet_owner"), // <-- explicitly set the column name
    }
}

In the near future we plan to implement Schema Versioning, which will store the history of schema changes alongside the code. Having this information will allow ent to support such migrations in an automatic and predictable way.

Wrapping Up

Edge-field support is readily available and can be installed by go get -u entgo.io/ent@v0.7.0.

Many thanks 🙏 to all the good people who took the time to give feedback and helped design this feature properly: Alex Snast, Ruben de Vries, Marwan Sulaiman, Andy Day, Sebastian Fekete and Joe Harvey.

For more Ent news and updates:

Follow us on twitter.com/entgo_io
Subscribe to our newsletter
Join us on #ent on the Gophers slack
Join us on the Ent Discord Server

Introducing ent

3 באוקטובר 2019 · 3 min read

Ariel Mashraki

The state of Go in Facebook Connectivity Tel Aviv

20 months ago, I joined Facebook Connectivity (FBC) team in Tel Aviv after ~5 years of programming in Go and embedding it in a few companies.
I joined a team that was working on a new project and we needed to choose a language for this mission. We compared a few languages and decided to go with Go.

Since then, Go continued to spread across other FBC projects and became a big success with around 15 Go engineers in Tel Aviv alone. New services are now written in Go.

The motivation for writing a new ORM in Go

Most of my work in my 5 years before Facebook was on infra tooling and micro-services without too much data-model work. A service that was needed to do a little amount of work with an SQL database used one of the existing open-source solutions, but one that had worked with a complicated data model was written in a different language with a robust ORM. For example, Python with SQLAlchemy.

At Facebook we like to think about our data-model in graph concepts. We've had a good experience with this model internally.
The lack of a proper Graph-based ORM for Go, led us to write one here with the following principles:

Schema As Code - defining types, relations and constraints should be in Go code (not struct tags), and should be validated using a CLI tool. We have good experience with a similar tool internally at Facebook.
Statically typed and explicit API using codegen - API with interface{}s everywhere affects developers efficiency; especially project newbies.
Queries, aggregations and graph traversals should be simple - developers don’t want to deal with raw SQL queries nor SQL terms.
Predicates should be statically typed. No strings everywhere.
Full support for context.Context - This helps us to get full visibility in our traces and logs systems, and it’s important for other features like cancellation.
Storage agnostic - we tried to keep the storage layer dynamic using codegen templates, since the development initially started on Gremlin (AWS Neptune) and switched later to MySQL.

Open-sourcing ent

ent is an entity framework (ORM) for Go, built with the principles described above. ent makes it possible to define any data model or graph-structure in Go code easily; The schema configuration is verified by entc (the ent codegen) that generates an idiomatic and statically-typed API that keeps Go developers productive and happy. It supports MySQL, MariaDB, PostgreSQL, SQLite, and Gremlin-based graph databases.

We’re open-sourcing ent today, and invite you to get started → entgo.io/docs/getting-started.

Protobuf Import Support​

Join the Schema Import Initiative​

Introduction​

Setting Up​

Generating Go Protobufs with entproto​

Generating a Fully Working gRPC Server from our Schema​

Creating the Server​

Creating the Client​

Caveats and Limitations​

Next Steps​

Before Edge-field Support​

With Edge-field Support​

Migrating Existing Schemas to Edge Fields​

Wrapping Up​

For more Ent news and updates:​

The state of Go in Facebook Connectivity Tel Aviv​

The motivation for writing a new ORM in Go​

Open-sourcing ent​

Protobuf Import Support

Join the Schema Import Initiative

Introduction

Setting Up

Generating Go Protobufs with `entproto`

Generating a Fully Working gRPC Server from our Schema

Creating the Server

Creating the Client

Caveats and Limitations

Next Steps

Before Edge-field Support

With Edge-field Support

Migrating Existing Schemas to Edge Fields

Wrapping Up

For more Ent news and updates:

The state of Go in Facebook Connectivity Tel Aviv

The motivation for writing a new ORM in Go

Open-sourcing ent