外部模板

ent 接受外部 Go 模板 以使用 --template 标志执行。 如果外部模板名在 ent 中已经定义过，它会覆盖已经定义的外部模板。 如果没有定义过，在命令执行完成后，会生成一个与外部模板同名的文件。 例如：

stringer.tmpl - 这个外部模板示例文件会生成一个叫做ent/stringer.go的文件。

  1. {{/* 下一行的作用是，告诉 Intellij/GoLand 等IDE，基于 gen.Graph 类型来启用自动补全功能。 */}}
  2. {{/* gotype: entgo.io/ent/entc/gen.Graph */}}
  5. {{ define "stringer" }}
  8. {{/* Add the base header for the generated file */}}
  9. {{ $pkg := base $.Config.Package }}
  10. {{ template "header" $ }}
  13. {{/* Loop over all nodes and implement the "GoStringer" interface */}}
  14. {{ range $n := $.Nodes }}
  15.     {{ $receiver := $n.Receiver }}
  16.     func ({{ $receiver }} *{{ $n.Name }}) GoString() string {
  17.         if {{ $receiver }} == nil {
  18.             return fmt.Sprintf("{{ $n.Name }}(nil)")
  19.         }
  20.         return {{ $receiver }}.String()
  21.     }
  22. {{ end }}
  25. {{ end }}

debug.tmpl - 这个模板文件会生成一个叫做ent/debug.go的文件

  1. {{ define "debug" }}
  4. {{/* 此模板用于给运行在debug模式下的每个 client<T> 添加一些功能。 */}}
  7. {{/* 给生成的文件添加头部信息 */}}
  8. {{ $pkg := base $.Config.Package }}
  9. {{ template "header" $ }}
  12. {{/* 循环遍历所有节点，并且给配置项添加 "Debug" 方法 */}}
  13. {{ range $n := $.Nodes }}
  14.     {{ $client := print $n.Name "Client" }}
  15.     func (c *{{ $client }}) Debug() *{{ $client }} {
  16.         if c.debug {
  17.             return c
  18.         }
  19.         cfg := config{driver: dialect.Debug(c.driver, c.log), log: c.log, debug: true, hooks: c.hooks}
  20.         return &{{ $client }}{config: cfg}
  21.     }
  22. {{ end }}
  25. {{ end }}

通过模板名对现有模板进行覆盖。 示例如下：

  1. {{/* 此模板用于给实体添加一些字段。 */}}
  2. {{ define "model/fields/additional" }}
  3.     {{- /* 给 "Card" 实体添加静态字段。 */}}
  4.     {{- if eq $.Name "Card" }}
  5.         // 通过模板定义静态字段。
  6.         StaticField string `json:"static_field,omitempty"`
  7.     {{- end }}
  8. {{ end }}

Helper Templates

As mentioned above, ent writes each template’s execution output to a file named the same as the template. For example, the output from a template defined as {{ define "stringer" }} will be written to a file named ent/stringer.go.

By default, ent writes each template declared with {{ define "<name>" }} to a file. However, it is sometimes desirable to define helper templates - templates that will not be invoked directly but rather be executed by other templates. To facilitate this use case, ent supports two naming formats that designate a template as a helper. The formats are:

1. {{ define "helper/.+" }} for global helper templates. For example:

  1. {{ define "helper/foo" }}
  2.     {{/* Logic goes here. */}}
  3. {{ end }}
  6. {{ define "helper/bar/baz" }}
  7.     {{/* Logic goes here. */}}
  8. {{ end }}

2. {{ define "<root-template>/helper/.+" }} for local helper templates. A template is considered as “root” if its execution output is written to a file. For example:

  1. {{/* A root template that is executed on the `gen.Graph` and will be written to a file named: `ent/http.go`.*/}}
  2. {{ define "http" }}
  3.     {{ range $n := $.Nodes }}
  4.         {{ template "http/helper/get" $n }}
  5.         {{ template "http/helper/post" $n }}
  6.     {{ end }}
  7. {{ end }}
  10. {{/* A helper template that is executed on `gen.Type` */}}
  11. {{ define "http/helper/get" }}
  12.     {{/* Logic goes here. */}}
  13. {{ end }}
  16. {{/* A helper template that is executed on `gen.Type` */}}
  17. {{ define "http/helper/post" }}
  18.     {{/* Logic goes here. */}}
  19. {{ end }}

Annotations

Schema annotations allow attaching metadata to fields and edges and inject them to external templates.
An annotation must be a Go type that is serializable to JSON raw value (e.g. struct, map or slice) and implement the Annotation interface.

Here’s an example of an annotation and its usage in schema and template:

1. 定义一个注解

  1. package entgql
  4. // Annotation annotates fields with metadata for templates.
  5. type Annotation struct {
  6.     // OrderField is the ordering field as defined in graphql schema.
  7.     OrderField string
  8. }
  11. // Name implements ent.Annotation interface.
  12. func (Annotation) Name() string {
  13.     return "EntGQL"
  14. }

2. Annotation usage in ent/schema:

  1. // User schema.
  2. type User struct {
  3.     ent.Schema
  4. }
  7. // Fields of the user.
  8. func (User) Fields() []ent.Field {
  9.     return []ent.Field{
  10.         field.Time("creation_date").
  11.             Annotations(entgql.Annotation{
  12.                 OrderField: "CREATED_AT",
  13.             }),
  14.     }
  15. }

3. 注解在外部模板中的用法：

  1. {{ range $node := $.Nodes }}
  2.     {{ range $f := $node.Fields }}
  3.         {{/* Get the annotation by its name. See: Annotation.Name */}}
  4.         {{ if $annotation := $f.Annotations.EntGQL }}
  5.             {{/* Get the field from the annotation. */}}
  6.             {{ $orderField := $annotation.OrderField }}
  7.         {{ end }}
  8.     {{ end }}
  9. {{ end }}

Global Annotations

Global annotation is a type of annotation that is injected into the gen.Config object and can be accessed globally in all templates. For example, an annotation that holds a config file information (e.g. gqlgen.yml or swagger.yml) add can accessed in all templates:

1. An annotation definition:

  1. package gqlconfig
  4. import (
  5.     "entgo.io/ent/schema"
  6.     "github.com/99designs/gqlgen/codegen/config"
  7. )
  10. // Annotation defines a custom annotation
  11. // to be inject globally to all templates.
  12. type Annotation struct {
  13.     Config *config.Config
  14. }
  17. func (Annotation) Name() string {
  18.     return "GQL"
  19. }
  22. var _ schema.Annotation = (*Annotation)(nil)

2. Annotation usage in ent/entc.go:

  1. func main() {
  2.     cfg, err := config.LoadConfig("<path to gqlgen.yml>")
  3.     if err != nil {
  4.         log.Fatalf("loading gqlgen config: %v", err)
  5.     }
  6.     opts := []entc.Option{
  7.         entc.TemplateDir("./template"),
  8.         entc.Annotations(gqlconfig.Annotation{Config: cfg}),
  9.     }
  10.     err = entc.Generate("./schema", &gen.Config{
  11.         Templates: entgql.AllTemplates,
  12.     }, opts...)
  13.     if err != nil {
  14.         log.Fatalf("running ent codegen: %v", err)
  15.     }
  16. }

3. Annotation usage in external templates:

  1. {{- with $.Annotations.GQL.Config.StructTag }}
  2.     {{/* Access the GQL configuration on *gen.Graph */}}
  3. {{- end }}
  6. {{ range $node := $.Nodes }}
  7.     {{- with $node.Config.Annotations.GQL.Config.StructTag }}
  8.         {{/* Access the GQL configuration on *gen.Type */}}
  9.     {{- end }}
  10. {{ end }}

Examples

  • 一个实现GraphQL Node API的自定义模板 - Github。

  • 一个用自定义函数执行外部模板的例子。 参阅配置和它的README文件。

Documentation

Templates are executed on either a specific node type, or the entire schema graph. For API documentation, see the GoDoc.

AutoCompletion

JetBrains users can add the following template annotation to enable the autocompletion in their templates:

  1. {{/* The line below tells Intellij/GoLand to enable the autocompletion based on the *gen.Graph type. */}}
  2. {{/* gotype: entgo.io/ent/entc/gen.Graph */}}
  5. {{ define "template" }}
  6.     {{/* ... */}}
  7. {{ end }}

See it in action:

template-autocomplete