Extensions

    Defining a New Extension

    All extension’s must implement the Extension interface:

    To simplify the development of new extensions, developers can embed to create extensions without implementing all methods:

    1. package hello
    3. // GreetExtension implements entc.Extension.
    4. type GreetExtension struct {
    5.     entc.DefaultExtension
    6. }

    Ent supports adding that will be rendered during code generation. To bundle such external templates on an extension, implement the Templates method:

    templates/greet.tmpl

    1. {{/* Tell Intellij/GoLand to enable the autocompletion based on the *gen.Graph type. */}}
    2. {{/* gotype: entgo.io/ent/entc/gen.Graph */}}
    4. {{ define "greet" }}
    6. {{/* Add the base header for the generated file */}}
    7. {{ $pkg := base $.Config.Package }}
    8. {{ template "header" $ }}
    10. {{ range $n := $.Nodes }}
    11.     {{ $receiver := $n.Receiver }}
    12.     func ({{ $receiver }} *{{ $n.Name }}) Greet() string {
    13.         return "Hello, {{ $n.Name }}"
    14.     }
    15. {{ end }}
    17. {{ end }}

    Adding Global Annotations

    2. type GreetingWord string
    4. // Name of the annotation. Used by the codegen templates.
    5. func (GreetingWord) Name() string {
    6.     return "GreetingWord"
    7. }

    Then add it to the GreetExtension struct:

    1. type GreetExtension struct {
    2.     entc.DefaultExtension
    3.     word GreetingWord
    4. }

    Next, implement the Annotations method:

    Now, from within your templates you can access the GreetingWord annotation:

    1. func ({{ $receiver }} *{{ $n.Name }}) Greet() string {
    2.     return "{{ $.Annotations.GreetingWord }}, {{ $n.Name }}"
    3. }

    The entc package provides an option to add a list of hooks (middlewares) to the code-generation phase. This option is ideal for adding custom validators for the schema, or for generating additional assets using the graph schema. To bundle code generation hooks with your extension, implement the Hooks method:

    1.     return []gen.Hook{
    2.         DisallowTypeName("Shalom"),
    3.     }
    4. }
    6. // DisallowTypeName ensures there is no ent.Schema with the given name in the graph.
    7. func DisallowTypeName(name string) gen.Hook {
    8.     return func(next gen.Generator) gen.Generator {
    9.         return gen.GenerateFunc(func(g *gen.Graph) error {
    11.                 if node.Name == name {
    12.                     return fmt.Errorf("entc: validation failed, type named %q not allowed", name)
    13.                 }
    14.             }
    15.             return next.Generate(g)
    16.         })
    17.     }
    18. }

    Using an Extension in Code Generation

    ent/entc.go


    • elk is an extension that generates RESTful API endpoints from Ent schemas. The extension generates HTTP CRUD handlers from the Ent schema, as well as an OpenAPI JSON file. By using it, you can easily build a RESTful HTTP server for your application. Please note, that elk has been discontinued in favor of entoas. An implementation generator is in the works.
      Read this blog post on how to work with elk, and on how to generate an OpenAPI Specification.

    • entoas is an extension that originates from elk and was ported into its own extension and is now the official generator for and opinionated OpenAPI Specification document. You can use this to rapidly develop and document a RESTful HTTP server. There will be a new extension released soon providing a generated implementation integrating for the document provided by entoas using ent.

    • entgql
      This extension helps users build servers from Ent schemas. entgql integrates with gqlgen, a popular, schema-first Go library for building GraphQL servers. The extension includes the generation of type-safe GraphQL filters, which enable users to effortlessly map GraphQL queries to Ent queries.
      Follow to get started.