gen

type Config struct {
	// Schema is the package path for the schema package.
	Schema string
	// Target is the filepath for the directory that holds the generated code.
	Target string
	// Package path 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
}

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 reference edge declared in the schema.
	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
	// Bidi indicates if this edge is a bidirectional edge. 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.
	//
	Bidi bool
}

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
}

type ForeignKey struct {
	// Field information for the foreign-key column.
	Field *Field
	// Edge that is associated with this foreign-key.
	Edge *Edge
}

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
}

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

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
}

type Op int

type Rel int

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
}

type SchemaMode uint

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.
}

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
	// ForeignKeys are the foreign-keys that resides in the type table.
	ForeignKeys []*ForeignKey
	// contains filtered or unexported fields
}

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