Ent Contrib

protoc-gen-entgrpc is a protoc plugin that generates server code implementing the gRPC interface derived from your ent.Schema.

It requires a path to the ent schema directory via the --entgrpc_opt=schema_path=... flag to map schema definitions to proto definitions. While the entproto CLI generates the necessary protoc invocation for you in a generate.go file, the manual command structure looks like this:

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

Current Limitations:

• Only "unique" edges (O2O, O2M) are supported; multi-relations are not yet supported.
• Mutating methods (Create/Update) currently set all fields, ignoring zero/null values and field nullability.
• All fields are copied from the gRPC request to the ent client; there is no current way to make specific fields non-settable via the service.

Follow these steps to integrate entoas into your Ent code generation workflow to produce an openapi.json file.

1. Create the extension runner: Create a file at ent/entc.go with the // +build ignore constraint. Use entoas.NewExtension() to create the extension and pass it to entc.Generate via entc.Extensions(ex).
2. Configure generation: Update ent/generate.go to point to your new entc.go file using a go:generate directive.
3. Execute: Run go generate ./... to trigger the Ent code generation and the entoas extension.

// ent/entc.go
// +build ignore

package main

import (
	"log"

	"entgo.io/ent/entc"
	"entgo.io/ent/entc/gen"
	"entgo.io/contrib/entoas"
)

func main() {
	ex, err := entoas.NewExtension()
	if err != nil {
		log.Fatalf("creating entoas extension: %v", err)
	}
	err = entc.Generate("./schema", &gen.Config{}, entc.Extensions(ex))
	if err != nil {
		log.Fatalf("running ent codegen: %v", err)
	}
}

Use entproto to facilitate the generation of .proto files from your ent.Schema. This process involves annotating your schema, running the entproto CLI, and then using go generate to create the Go code for the protocol buffers and gRPC services.

Prerequisites

• Install protoc
• Install protoc-gen-go and protoc-gen-go-grpc

Steps

1. Install dependencies:

   go get -u entgo.io/contrib/entproto
   go get entgo.io/contrib/entproto/cmd/protoc-gen-entgrpc

2. Annotate your schema: Add entproto.Message() to the schema annotations and assign field numbers using entproto.Field(n). Note that field number 1 is reserved for the schema's ID field.

3. Run code generation:

   go run entgo.io/contrib/entproto/cmd/entproto -path ./ent/schema

4. Generate Go files: The previous step creates a .proto file and a generate.go file. Run the following to generate the final Go code:

   go generate ./ent/proto/...

package schema

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

type User struct {
	ent.Schema
}

func (User) Annotations() []schema.Annotation {
	return []schema.Annotation{
		entproto.Message(),
		entproto.Service(), // also generate a gRPC service definition
	}
}

func (User) Fields() []ent.Field {
	return []ent.Field{
		field.String("user_name").
			Annotations(entproto.Field(2)),
	}
}