ent: github.com/facebookincubator/ent/entc/gen Index | Files | Directories

package gen

import "github.com/facebookincubator/ent/entc/gen"

Package gen is the interface for generating loaded schemas into a Go package.

Index

Package Files

func.go graph.go predicate.go storage.go template.go type.go

Variables

var (
    // Templates holds the template information for a file that the graph is generating.
    Templates = []TypeTemplate{
        {
            Name:   "create",
            Format: pkgf("%s_create.go"),
        },
        {
            Name:   "update",
            Format: pkgf("%s_update.go"),
        },
        {
            Name:   "delete",
            Format: pkgf("%s_delete.go"),
        },
        {
            Name:   "query",
            Format: pkgf("%s_query.go"),
        },
        {
            Name:   "model",
            Format: pkgf("%s.go"),
        },
        {
            Name:   "where",
            Format: pkgf("%s/where.go"),
        },
        {
            Name: "meta",
            Format: func(t *Type) string {
                return fmt.Sprintf("%s/%s.go", t.Package(), t.Package())
            },
        },
    }
    // GraphTemplates holds the templates applied on the graph.
    GraphTemplates = []GraphTemplate{
        {
            Name:   "base",
            Format: "ent.go",
        },
        {
            Name:   "client",
            Format: "client.go",
        },
        {
            Name:   "context",
            Format: "context.go",
        },
        {
            Name:   "tx",
            Format: "tx.go",
        },
        {
            Name:   "config",
            Format: "config.go",
        },
        {
            Name:   "migrate",
            Format: "migrate/migrate.go",
            Skip:   func(g *Graph) bool { return !g.migrateSupport() },
        },
        {
            Name:   "schema",
            Format: "migrate/schema.go",
            Skip:   func(g *Graph) bool { return !g.migrateSupport() },
        },
        {
            Name:   "predicate",
            Format: "predicate/predicate.go",
        },
        {
            Name:   "example",
            Format: "example_test.go",
        },
    }
)
var (
    // Funcs are the predefined template
    // functions used by the codegen.
    Funcs = template.FuncMap{
        "ops":         ops,
        "add":         add,
        "append":      reflect.Append,
        "appends":     reflect.AppendSlice,
        "order":       order,
        "snake":       snake,
        "pascal":      pascal,
        "extend":      extend,
        "xrange":      xrange,
        "receiver":    receiver,
        "plural":      plural,
        "aggregate":   aggregate,
        "primitives":  primitives,
        "singular":    rules.Singularize,
        "quote":       strconv.Quote,
        "base":        filepath.Base,
        "keys":        keys,
        "join":        join,
        "lower":       strings.ToLower,
        "upper":       strings.ToUpper,
        "hasField":    hasField,
        "indirect":    indirect,
        "hasSuffix":   strings.HasSuffix,
        "trimPackage": trimPackage,
        "xtemplate":   xtemplate,
        "hasTemplate": hasTemplate,
    }
)

type Config Uses

type Config struct {
    // Schema is the package path for the schema directory.
    Schema string
    // Target is the path for the directory that holding the generated code.
    Target string
    // Package name for the targeted directory that holds the generated code.
    Package string
    // Header is an optional header signature for generated files.
    Header string
    // Storage to support in codegen.
    Storage []*Storage
    // IDType specifies the type of the id field in the codegen.
    // The supported types are string and int, which also the default.
    IDType *field.TypeInfo
    // Template specifies an alternative template to execute or to override
    // the default. If nil, the default template is used.
    //
    // Note that, additional templates are executed on the Graph object and
    // the execution output is stored in a file derived by the template name.
    Template *template.Template
}

Config for global generator configuration that similar for all nodes.

func (*Config) MultiStorage Uses

func (c *Config) MultiStorage() bool

MultiStorage reports whether c has more than 1 storage driver.

type Edge Uses

type Edge struct {
    // Name holds the name of the edge.
    Name string
    // Type holds a reference to the type this edge is directed to.
    Type *Type
    // Optional indicates is this edge is optional on create.
    Optional bool
    // Unique indicates if this edge is a unique edge.
    Unique bool
    // Inverse holds the name of the inverse edge.
    Inverse string
    // Owner holds the type of the edge-owner. For assoc-edges it's the
    // type that holds the edge, for inverse-edges, it's the assoc type.
    Owner *Type
    // StructTag of the edge-field in the struct. default to "json".
    StructTag string
    // Relation holds the relation info of an edge.
    Rel Relation
    // SelfRef indicates if this edge is a self-reference to the same
    // type with the same name (symmetric relation). For example, a User
    // type have one of following edges:
    //
    //	edge.To("friends", User.Type)           // many 2 many.
    //	edge.To("spouse", User.Type).Unique()   // one 2 one.
    //
    SelfRef bool
}

Edge of a graph between two types.

func (Edge) BuilderField Uses

func (e Edge) BuilderField() string

BuilderField returns the struct member of the edge in the builder.

func (Edge) ColumnConstant Uses

func (e Edge) ColumnConstant() string

ColumnConstant returns the constant name of the relation column.

func (Edge) Constant Uses

func (e Edge) Constant() string

Constant returns the constant name of the edge. If the edge is inverse, it returns the constant name of the owner-edge (assoc-edge).

func (Edge) HasConstraint Uses

func (e Edge) HasConstraint() bool

HasConstraint indicates if this edge has a unique constraint check. We check uniqueness when both-directions are unique or one of them.

func (Edge) InverseConstant Uses

func (e Edge) InverseConstant() string

InverseConstant returns the inverse constant name of the edge.

func (Edge) InverseTableConstant Uses

func (e Edge) InverseTableConstant() string

InverseTableConstant returns the constant name of the other/inverse type of the relation.

func (Edge) IsInverse Uses

func (e Edge) IsInverse() bool

IsInverse returns if this edge is an inverse edge.

func (Edge) Label Uses

func (e Edge) Label() string

Label returns the Gremlin label name of the edge. If the edge is inverse

func (Edge) M2M Uses

func (e Edge) M2M() bool

M2M indicates if this edge is M2M edge.

func (Edge) M2O Uses

func (e Edge) M2O() bool

M2O indicates if this edge is M2O edge.

func (Edge) O2M Uses

func (e Edge) O2M() bool

O2M indicates if this edge is O2M edge.

func (Edge) O2O Uses

func (e Edge) O2O() bool

O2O indicates if this edge is O2O edge.

func (Edge) PKConstant Uses

func (e Edge) PKConstant() string

PKConstant returns the constant name of the primary key. Used for M2M edges.

func (Edge) StructField Uses

func (e Edge) StructField() string

StructField returns the struct member of the edge in the model.

func (Edge) TableConstant Uses

func (e Edge) TableConstant() string

TableConstant returns the constant name of the relation table.

type Field Uses

type Field struct {

    // Name is the name of this field in the database schema.
    Name string
    // Type holds the type information of the field.
    Type *field.TypeInfo
    // Unique indicate if this field is a unique field.
    Unique bool
    // Optional indicates is this field is optional on create.
    Optional bool
    // Nillable indicates that this field can be null in the
    // database and pointer in the generated entities.
    Nillable bool
    // Default indicates if this field has a default value for creation.
    Default bool
    // UpdateDefault indicates if this field has a default value for update.
    UpdateDefault bool
    // Immutable indicates is this field cannot be updated.
    Immutable bool
    // StructTag of the field. default to "json".
    StructTag string
    // Validators holds the number of validators this field have.
    Validators int
    // Position info of the field.
    Position *load.Position
    // UserDefined indicates that this field was defined by the loaded schema.
    // Unlike default id field, which is defined by the generator.
    UserDefined bool
    // contains filtered or unexported fields
}

Field holds the information of a type field used for the templates.

func (Field) BuilderField Uses

func (f Field) BuilderField() string

BuilderField returns the struct member of the field in the builder.

func (Field) Column Uses

func (f Field) Column() *schema.Column

Column returns the table column. It sets it as a primary key (auto_increment) in case of ID field.

func (Field) Constant Uses

func (f Field) Constant() string

Constant returns the constant name of the field.

func (Field) DefaultName Uses

func (f Field) DefaultName() string

DefaultName returns the variable name of the default value of this field.

func (Field) Enums Uses

func (f Field) Enums() []string

Enums returns the enum values of a field.

func (Field) ExampleCode Uses

func (f Field) ExampleCode() string

ExampleCode returns an example code of the field value for the example_test file.

func (Field) IsEnum Uses

func (f Field) IsEnum() bool

IsEnum returns true if the field is an enum field.

func (Field) IsInt Uses

func (f Field) IsInt() bool

IsInt returns true if the field is an int field.

func (Field) IsJSON Uses

func (f Field) IsJSON() bool

IsJSON returns true if the field is a JSON field.

func (Field) IsString Uses

func (f Field) IsString() bool

IsString returns true if the field is a string field.

func (Field) IsTime Uses

func (f Field) IsTime() bool

IsTime returns true if the field is a timestamp field.

func (Field) NullType Uses

func (f Field) NullType() string

NullType returns the sql null-type for optional and nullable fields.

func (Field) NullTypeField Uses

func (f Field) NullTypeField(rec string) string

NullTypeField extracts the nullable type field (if exists) from the given receiver. It also does the type conversion if needed.

func (Field) Sensitive Uses

func (f Field) Sensitive() bool

Sensitive returns true if the field is a sensitive field.

func (Field) StorageKey Uses

func (f Field) StorageKey() string

StorageKey returns the storage name of the field. SQL columns or Gremlin property.

func (Field) StructField Uses

func (f Field) StructField() string

StructField returns the struct member of the field in the model.

func (Field) UpdateDefaultName Uses

func (f Field) UpdateDefaultName() string

UpdateDefaultName returns the variable name of the update default value of this field.

func (Field) Validator Uses

func (f Field) Validator() string

Validator returns the validator name.

type Graph Uses

type Graph struct {
    *Config
    // Nodes are list of Go types that mapped to the types in the loaded schema.
    Nodes []*Type
    // Schemas holds the raw interfaces for the loaded schemas.
    Schemas []*load.Schema
}

Graph holds the nodes/entities of the loaded graph schema. Note that, it doesn't hold the edges of the graph. Instead, each Type holds the edges for other Types.

func NewGraph Uses

func NewGraph(c *Config, schemas ...*load.Schema) (g *Graph, err error)

NewGraph creates a new Graph for the code generation from the given schema definitions. It fails if one of the schemas is invalid.

func (*Graph) Gen Uses

func (g *Graph) Gen() (err error)

Gen generates the artifacts for the graph.

func (*Graph) Tables Uses

func (g *Graph) Tables() (all []*schema.Table)

Tables returns the schema definitions of SQL tables for the graph.

type GraphTemplate Uses

type GraphTemplate struct {
    Name   string            // template name.
    Format string            // file name format.
    Skip   func(*Graph) bool // skip condition.
}

GraphTemplate specifies a template that is executed with the Graph object.

type Index Uses

type Index struct {
    // Name of the index. One column index is simply the column name.
    Name string
    // Unique index or not.
    Unique bool
    // Columns are the table columns.
    Columns []string
}

Index represents a database index used for either increasing speed on database operations or defining constraints such as "UNIQUE INDEX". Note that some indexes are created implicitly like table foreign keys.

type Op Uses

type Op int

Op is a predicate for the where clause.

const (
    EQ           Op  = iota // =
    NEQ                     // <>
    GT                      // >
    GTE                     // >=
    LT                      // <
    LTE                     // <=
    IsNil                   // IS NULL / has
    NotNil                  // IS NOT NULL / hasNot
    In                      // within
    NotIn                   // without
    EqualFold               // equals case-insensitive
    Contains                // containing
    ContainsFold            // containing case-insensitive
    HasPrefix               // startingWith
    HasSuffix               // endingWith
)

List of all builtin predicates.

func (Op) Name Uses

func (o Op) Name() string

Name returns the string representation of an predicate.

func (Op) Niladic Uses

func (o Op) Niladic() bool

Niladic reports if the predicate is a niladic predicate.

func (Op) Variadic Uses

func (o Op) Variadic() bool

Variadic reports if the predicate is a variadic function.

type Rel Uses

type Rel int

Rel is a relation type of an edge.

const (
    Unk Rel = iota // Unknown.
    O2O            // One to one / has one.
    O2M            // One to many / has many.
    M2O            // Many to one (inverse perspective for O2M).
    M2M            // Many to many.
)

Relation types.

func (Rel) String Uses

func (r Rel) String() string

String returns the relation name.

type Relation Uses

type Relation struct {
    // Type holds the relation type of the edge.
    Type Rel
    // Table holds the relation table for this edge.
    // For O2O and O2M, it's the table name of the type we're this edge point to.
    // For M2O, this is the owner's type, and for M2M this is the join table.
    Table string
    // Columns holds the relation column in the relation table above.
    // In O2M, M2O and O2O, this the first element.
    Columns []string
}

Relation holds the relational database information for edges.

func (Relation) Column Uses

func (r Relation) Column() string

Column returns the first element from the columns slice.

type SchemaMode Uses

type SchemaMode uint

A SchemaMode defines what type of schema feature a storage driver support.

const (
    // Unique defines field and edge uniqueness support.
    Unique SchemaMode = 1 << iota

    // Indexes defines indexes support.
    Indexes

    // Cascade defines cascading operations (e.g. cascade deletion).
    Cascade

    // Migrate defines static schema and migration support (e.g. SQL-based).
    Migrate
)

func (SchemaMode) Support Uses

func (m SchemaMode) Support(mode SchemaMode) bool

Support reports whether m support the given mode.

type Storage Uses

type Storage struct {
    Name       string            // storage name.
    Builder    reflect.Type      // query builder type.
    Dialects   []string          // supported dialects.
    IdentName  string            // identifier name (fields and funcs).
    Imports    []string          // import packages needed.
    SchemaMode SchemaMode        // schema mode support.
    Ops        func(*Field) []Op // storage specific operations.
    OpCode     func(Op) string   // operation code for predicates.
}

Storage driver type for codegen.

func NewStorage Uses

func NewStorage(s string) (*Storage, error)

NewStorage returns a the storage driver type from the given string. It fails if the provided string is not a valid option. this function is here in order to remove the validation logic from entc command line.

func (*Storage) String Uses

func (s *Storage) String() string

String implements the fmt.Stringer interface for template usage.

type Type Uses

type Type struct {
    *Config

    // Name holds the type/ent name.
    Name string
    // ID holds the ID field of this type.
    ID  *Field
    // Fields holds all the primitive fields of this type.
    Fields []*Field

    // Edge holds all the edges of this type.
    Edges []*Edge
    // Indexes are the configured indexes for this type.
    Indexes []*Index
    // contains filtered or unexported fields
}

Type represents one node-type in the graph, its relations and the information it holds.

func NewType Uses

func NewType(c *Config, schema *load.Schema) (*Type, error)

NewType creates a new type and its fields from the given schema.

func (*Type) AddIndex Uses

func (t *Type) AddIndex(idx *load.Index) error

AddIndex adds a new index for the type. It fails if the schema index is invalid.

func (Type) HasAssoc Uses

func (t Type) HasAssoc(name string) (*Edge, bool)

HasAssoc returns true if this type has an assoc edge with the given name. faster than map access for most cases.

func (Type) HasDefault Uses

func (t Type) HasDefault() bool

HasDefault reports if any of this type's fields has default value on creation.

func (Type) HasOptional Uses

func (t Type) HasOptional() bool

HasOptional reports if this type has an optional field.

func (Type) HasUpdateDefault Uses

func (t Type) HasUpdateDefault() bool

HasUpdateDefault reports if any of this type's fields has default value on update.

func (Type) HasValidators Uses

func (t Type) HasValidators() bool

HasValidators reports if any of the type's field has validators.

func (Type) Label Uses

func (t Type) Label() string

Label returns Gremlin label name of the node/type.

func (Type) MixedInWithDefault Uses

func (t Type) MixedInWithDefault() (fields []*Field)

MixedInWithDefault returns all mixed-in fields with default values for creation or update.

func (Type) MutableFields Uses

func (t Type) MutableFields() []*Field

MutableFields returns the types's mutable fields.

func (Type) NumConstraint Uses

func (t Type) NumConstraint() int

NumConstraint returns the type's constraint count. Used for slice allocation.

func (Type) NumM2M Uses

func (t Type) NumM2M() int

NumM2M returns the type's many-to-many edge count

func (Type) NumMixin Uses

func (t Type) NumMixin() int

NumMixin returns the type's mixin count.

func (Type) Package Uses

func (t Type) Package() string

Package returns the package name of this node.

func (Type) Receiver Uses

func (t Type) Receiver() string

Receiver returns the receiver name of this node. It makes sure the receiver names doesn't conflict with import names.

func (Type) Table Uses

func (t Type) Table() string

Table returns SQL table name of the node/type.

func (Type) TagTypes Uses

func (t Type) TagTypes() []string

TagTypes returns all struct-tag types of the type fields.

type TypeTemplate Uses

type TypeTemplate struct {
    Name   string             // template name.
    Format func(*Type) string // file name format.
}

TypeTemplate specifies a template that is executed with each Type object of the graph.

Directories

PathSynopsis
internalPackage internal Code generated by go-bindata.

Package gen imports 22 packages (graph) and is imported by 1 packages. Updated 2019-11-19. Refresh now. Tools for package owners.