Mixin

A Mixin allows you to create reusable pieces of ent.Schema code that can be injected into other schemas using composition.

The ent.Mixin interface is as follows:

  1. type Mixin interface {
  2.     // Fields returns a slice of fields to add to the schema.
  3.     Fields() []Field
  4.     // Edges returns a slice of edges to add to the schema.
  5.     Edges() []Edge
  6.     // Indexes returns a slice of indexes to add to the schema.
  7.     Indexes() []Index
  8.     // Hooks returns a slice of hooks to add to the schema.
  9.     // Note that mixin hooks are executed before schema hooks.
  10.     Hooks() []Hook
  11.     // Policy returns a privacy policy to add to the schema.
  12.     // Note that mixin policy are executed before schema policy.
  13.     Policy() Policy
  14.     // Annotations returns a list of schema annotations to add
  15.     // to the schema annotations.
  16.     Annotations() []schema.Annotation
  17. }

Example

A common use case for Mixin is to mix-in a list of common fields to your schema.

  1. package schema
  3. import (
  4.     "time"
  6.     "entgo.io/ent"
  7.     "entgo.io/ent/schema/field"
  8.     "entgo.io/ent/schema/mixin"
  9. )
  11. // -------------------------------------------------
  12. // Mixin definition
  14. // TimeMixin implements the ent.Mixin for sharing
  15. // time fields with package schemas.
  16. type TimeMixin struct{
  17.     // We embed the `mixin.Schema` to avoid
  18.     // implementing the rest of the methods.
  19.     mixin.Schema
  20. }
  22. func (TimeMixin) Fields() []ent.Field {
  23.     return []ent.Field{
  24.         field.Time("created_at").
  25.             Immutable().
  26.             Default(time.Now),
  27.         field.Time("updated_at").
  28.             Default(time.Now).
  29.             UpdateDefault(time.Now),
  30.     }
  31. }
  33. // DetailsMixin implements the ent.Mixin for sharing
  34. // entity details fields with package schemas.
  35. type DetailsMixin struct{
  36.     // We embed the `mixin.Schema` to avoid
  37.     // implementing the rest of the methods.
  38.     mixin.Schema
  39. }
  41. func (DetailsMixin) Fields() []ent.Field {
  42.     return []ent.Field{
  43.         field.Int("age").
  44.             Positive(),
  45.         field.String("name").
  46.             NotEmpty(),
  47.     }
  48. }
  50. // -------------------------------------------------
  51. // Schema definition
  53. // User schema mixed-in the TimeMixin and DetailsMixin fields and therefore
  54. // has 5 fields: `created_at`, `updated_at`, `age`, `name` and `nickname`.
  55. type User struct {
  56.     ent.Schema
  57. }
  59. func (User) Mixin() []ent.Mixin {
  60.     return []ent.Mixin{
  61.         TimeMixin{},
  62.         DetailsMixin{},
  63.     }
  64. }
  66. func (User) Fields() []ent.Field {
  67.     return []ent.Field{
  68.         field.String("nickname").
  69.             Unique(),
  70.     }
  71. }
  73. // Pet schema mixed-in the DetailsMixin fields and therefore
  74. // has 3 fields: `age`, `name` and `weight`.
  75. type Pet struct {
  76.     ent.Schema
  77. }
  79. func (Pet) Mixin() []ent.Mixin {
  80.     return []ent.Mixin{
  81.         DetailsMixin{},
  82.     }
  83. }
  85. func (Pet) Fields() []ent.Field {
  86.     return []ent.Field{
  87.         field.Float("weight"),
  88.     }
  89. }

Builtin Mixin

Package mixin provides a few builtin mixins that can be used for adding the create_time and update_time fields to the schema.

In order to use them, add the mixin.Time mixin to your schema as follows:

  1. package schema
  3. import (
  4.     "entgo.io/ent"
  5.     "entgo.io/ent/schema/mixin"
  6. )
  8. type Pet struct {
  9.     ent.Schema
  10. }
  12. func (Pet) Mixin() []ent.Mixin {
  13.     return []ent.Mixin{
  14.         mixin.Time{},
  15.         // Or, mixin.CreateTime only for create_time
  16.         // and mixin.UpdateTime only for update_time.
  17.     }
  18. }