Extensions

    Defining a New Extension

    All extension’s must implement the interface:

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

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

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

    1. {{/* Tell Intellij/GoLand to enable the autocompletion based on the *gen.Graph type. */}}
    2. {{/* gotype: entgo.io/ent/entc/gen.Graph */}}
    5. {{ define "greet" }}
    8. {{/* Add the base header for the generated file */}}
    9. {{ $pkg := base $.Config.Package }}
    12. {{/* Loop over all nodes and add the Greet method */}}
    13. {{ range $n := $.Nodes }}
    14.     {{ $receiver := $n.Receiver }}
    16.         return "Hello, {{ $n.Name }}"
    17.     }
    18. {{ end }}
    21. {{ end }}

    Adding Global Annotations

    Annotations are a convenient way to supply users of our extension with an API to modify the behavior of code generation. To add annotations to our extension, implement the Annotations method. Let’s say in our GreetExtension we want to provide users with the ability to configure the greeting word in the generated code:

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

    Then add it to the GreetExtension struct:

    1. type GreetExtension struct {
    2.     entc.DefaultExtension
    3. }

    Next, implement the Annotations method:

    2.     return "{{ $.Annotations.GreetingWord }}, {{ $n.Name }}"
    3. }

    The entc package provides an option to add a list of (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. func (s *GreetExtension) Hooks() []gen.Hook {
    2.     return []gen.Hook{
    3.         DisallowTypeName("Shalom"),
    4.     }
    5. }
    8. // DisallowTypeName ensures there is no ent.Schema with the given name in the graph.
    9. func DisallowTypeName(name string) gen.Hook {
    10.     return func(next gen.Generator) gen.Generator {
    11.         return gen.GenerateFunc(func(g *gen.Graph) error {
    12.             for _, node := range g.Nodes {
    13.                 if node.Name == name {
    14.                     return fmt.Errorf("entc: validation failed, type named %q not allowed", name)
    15.                 }
    16.             }
    17.             return next.Generate(g)
    18.         })
    19. }

    Using an Extension in Code Generation

    To use an extension in our code-generation configuration, use , a helper method that returns an entc.Option that applies our chosen extensions:

    ent/entc.go