Generating Schemas

    In order to manipulate an existing schema directory we must first load it into a schemast.Context object:

    To print back out our context to a target directory, use schemast.Print:

    1. package main
    3. import (
    4.     "log"
    6.     "entgo.io/contrib/schemast"
    7. )
    9. func main() {
    10.     ctx, err := schemast.Load("./ent/schema")
    11.     if err != nil {
    12.         log.Fatalf("failed: %v", err)
    13.     }
    14.     // A no-op since we did not manipulate the Context at all.
    15.     if err := schemast.Print("./ent/schema"); err != nil {
    16.         log.Fatalf("failed: %v", err)
    17.     }
    18. }
    1. package schemast
    3. // Mutator changes a Context.
    4. type Mutator interface {
    5.     Mutate(ctx *Context) error
    6. }

    Currently, only a single type of schemast.Mutator is implemented, UpsertSchema:

    To use it:

    1. package main
    3.     "log"
    5.     "entgo.io/contrib/schemast"
    6.     "entgo.io/ent"
    7.     "entgo.io/ent/schema/field"
    8. )
    10. func main() {
    11.     ctx, err := schemast.Load("./ent/schema")
    12.     if err != nil {
    13.         log.Fatalf("failed: %v", err)
    14.     }
    15.     mutations := []schemast.Mutator{
    16.         &schemast.UpsertSchema{
    17.             Name: "User",
    18.             Fields: []ent.Field{
    19.                 field.String("name"),
    20.             },
    21.         },
    22.         &schemast.UpsertSchema{
    23.             Name: "Team",
    24.             Fields: []ent.Field{
    25.                 field.String("name"),
    26.             },
    27.         },
    28.     }
    29.     err = schemast.Mutate(ctx, mutations...)
    30.     if err := ctx.Print("./ent/schema"); err != nil {
    31.         log.Fatalf("failed: %v", err)
    32.     }
    33. }
    1. // user.go
    2. package schema
    4.     "entgo.io/ent"
    5.     "entgo.io/ent/schema"
    6.     "entgo.io/ent/schema/field"
    9. type User struct {
    10.     ent.Schema
    11. }
    13. func (User) Fields() []ent.Field {
    14.     return []ent.Field{field.String("name")}
    15. }
    16. func (User) Edges() []ent.Edge {
    17.     return nil
    18. }
    19. func (User) Annotations() []schema.Annotation {
    20.     return nil
    21. }

    Edges are defined in ent this way:

    1. edge.To("edge_name", OtherSchema.Type)

    This syntax relies on the fact that the OtherSchema struct already exists when we define the edge so we can refer to its Type method. When we are generating schemas programmatically, obviously we need somehow to describe the edge to the code-generator before the type definitions exist. To do this you can do something like:

    1. type placeholder struct {
    2.     ent.Schema
    3. }
    5. func withType(e ent.Edge, typeName string) ent.Edge {
    6.     e.Descriptor().Type = typeName
    7.     return e
    8. }
    10. func newEdgeTo(edgeName, otherType string) ent.Edge {
    11.     // we pass a placeholder type to the edge constructor:
    12.     e := edge.To(edgeName, placeholder.Type)
    13.     // then we override the other type's name directly on the edge descriptor: 
    14.     return withType(e, otherType)
    15. }

    schemast is still experimental, APIs are subject to change in the future. In addition, a small portion of the definition API is unsupported at this point in time, to see a full list of unsupported features see the source code.