codegen

type CheckConstraint struct {
	Name string `json:"name"`
	Expr string `json:"expr,omitempty"`
}

type Column struct {
	Name    string `json:"name"`
	Type    string `json:"type"`
	NotNull bool   `json:"notNull"`
	Default string `json:"default,omitempty"`
	Check   string `json:"check,omitempty"`
	Ref     string `json:"ref,omitempty"`
	PK      bool   `json:"pk,omitempty"`

	// Foreign key detail. Ref names the referenced table; RefColumn names the
	// referenced column and defaults to "id" when empty. The actions are stored
	// in SQL form ("CASCADE", "SET NULL", ...).
	RefColumn  string `json:"refColumn,omitempty"`
	OnDelete   string `json:"onDelete,omitempty"`
	OnUpdate   string `json:"onUpdate,omitempty"`
	Deferrable bool   `json:"deferrable,omitempty"`

	// RenamedFrom is the column's previous name. Diff-time only; see Table.
	RenamedFrom string `json:"-"`
}

type Config struct {
	Packages []string       `yaml:"packages"`
	Modules  []ModuleConfig `yaml:"modules"`
	Output   OutputConfig   `yaml:"output"`
	Dialect  string         `yaml:"dialect"`
	// Seed is an optional path to a Go main package that seeds the database.
	// `drel seed` runs it with `go run`, passing through DATABASE_URL.
	Seed string `yaml:"seed"`

	// NoSlices records that the file declares an empty packages or modules
	// list. An application with no feature slice yet is a valid state: codegen
	// writes the aggregated DB file and generates no model. It differs from a
	// file that declares neither key, which is a mistake.
	NoSlices bool `yaml:"-"`
}

type Drift struct {
	// Unmanaged lists objects the database holds that no model declares. Each
	// one is invisible to the migration differ, so a later migration is planned
	// as though it did not exist.
	Unmanaged []DriftItem
	// Missing lists objects the models declare that the database does not hold.
	// The usual cause is an unapplied migration.
	Missing []DriftItem
	// Different lists objects both sides hold in a different shape.
	Different []DriftItem
}

type DriftItem struct {
	Kind   string // "table", "column", "index", "foreign key", "check constraint", "enum"
	Table  string
	Name   string
	Detail string
}

type EnumDef struct {
	Name     string   `json:"name"`
	Values   []string `json:"values"`
	IsInt    bool     `json:"isInt,omitempty"`
	BaseType string   `json:"baseType,omitempty"`
}

type FieldInfo struct {
	Name       string
	GoType     string
	ColumnName string
	// RenamedFrom, when set, is this column's previous name. The migration
	// differ turns it into an ALTER TABLE ... RENAME COLUMN rather than a drop
	// and an add.
	RenamedFrom string
	IsExported  bool
	RelTag      string
	Relation    *RelationFieldInfo
	IsVO        bool // implements sql.Scanner + driver.Valuer (single-column VO)
	// IsDate marks drel.Date, which is a value object whose column type no
	// inference rule reaches: codegen reads types and never runs a method.
	IsDate         bool
	VOBaseType     string   // single-column VO: underlying basic Go type (e.g. "string", "int64"); empty if not derivable
	HasEqual       bool     // single-column VO defines an Equal(T) bool method usable for diffing
	IsComparable   bool     // single-column VO's Go type is comparable with == / != (types.Comparable)
	HasIsZero      bool     // single-column VO defines IsZero() bool, enabling the zero<->NULL bridge
	IsMultiColVO   bool     // implements drel.MultiColumnMapper (multi-column VO)
	MultiColPrefix string   // db tag used as column prefix for multi-column VOs
	MultiColNames  []string // expanded sub-column names from the db tag (multi-column VOs)
	MultiColTypes  []string // resolved SQL types per sub-column (default "text"; multi-column VOs)
	LocalGoType    string   // type name without package qualifier, for same-package generated code
	TypePkgPath    string   // import path of the field type's package (empty for primitives/same-package)
	// TypeRefPkgs lists the import paths an unnamed composite type refers to,
	// e.g. []time.Time needs "time". LocalGoType then holds placeholders that
	// the emitter replaces with the file's import aliases.
	TypeRefPkgs      []string
	IsPointer        bool // whether the field is a pointer type
	IsEnum           bool
	EnumValues       []string
	EnumIsInt        bool   // enum's underlying basic kind is integer (not string)
	EnumBaseType     string // Go base type of the enum, e.g. "string", "int", "int64"
	IsNamedPrimitive bool   // named type over a comparable basic kind with no enum consts (e.g. type Priority int)
	Unique           bool   // db tag option: unique index on this column
	Indexed          bool   // db tag option: index on this column
	// IndexNames lists the named indexes this column joins. A field may join
	// several: `db:"user_id,index=idx_a,index=idx_b"`. Fields sharing a name
	// compose one index, ordered by field declaration order.
	IndexNames []IndexMembership
	// References names the table this column points at, for a foreign key
	// declared with `db:"...,references=table[.column]"`. The target needs no
	// drel model, so a column can reference a table another system owns.
	References   string
	RefColumn    string // referenced column; "id" when the tag omits it
	OnDelete     string // ON DELETE action, already in SQL form (e.g. "CASCADE")
	OnUpdate     string // ON UPDATE action, already in SQL form
	Deferrable   bool   // emit DEFERRABLE INITIALLY DEFERRED
	CheckExpr    string // db tag option: column CHECK constraint expression (db:"...,check=expr")
	Default      string // db tag option: column DEFAULT value (db:"...,default=expr")
	TypeOverride string // db tag option: explicit SQL type (db:"...,type=jsonb"); overrides inference
	IsJSON       bool   // map/slice/struct mapped as JSON/jsonb (default for non-primitive, non-VO, non-enum container types)
	IsArray      bool   // slice field (JSON array by default; native T[] when TypeOverride is set on Postgres)
}

type FieldKind int

type Index struct {
	Name    string   `json:"name"`
	Columns []string `json:"columns"`
	Unique  bool     `json:"unique,omitempty"`
	// Where is a partial-index predicate. An index with a predicate covers only
	// the rows that satisfy it, which is how a "one active row per user" rule is
	// expressed as a unique index.
	Where string `json:"where,omitempty"`
}

type IndexDecl struct {
	Name    string
	Columns []string
	Unique  bool
	Where   string
}

type IndexMembership struct {
	Name   string
	Unique bool
	Where  string // partial-index predicate; empty for a full index
}

type KeyColumn struct {
	FieldName  string // exported Go field on the key struct; empty for a scalar key
	ColumnName string // database column name
	GoType     string // local Go type name, e.g. "int" or "UUID"
	// PkgPath is the import path of the field's type. It is empty for a
	// builtin type and for a type declared in the model's own package.
	PkgPath string
	// UnderlyingGoType is the normalization kind of the column: "int" for any
	// signed integer, "string", or "uuid.UUID". It selects the conversion
	// rule and names the type the conversion helper returns, which is not
	// always GoType: a named type or a sized integer needs a conversion back.
	UnderlyingGoType string
}

type ModelInfo struct {
	Name       string
	PkgPath    string
	PkgName    string
	PKType     string // display type for generated code (e.g., "int", "uuid.UUID")
	PKTypeFull string // fully qualified (e.g., "github.com/google/uuid.UUID")
	PKTypePkg  string // import path for external PK types (empty for primitives)
	TableName  string
	// RenamedFrom, when set, is this table's previous name. The migration
	// differ turns it into an ALTER TABLE ... RENAME TO.
	RenamedFrom   string
	Fields        []FieldInfo
	HasSoftDelete bool
	HasVersioned  bool
	HasAudit      bool
	Dir           string // filesystem directory of the package
	// Module is the feature slice this model belongs to. It is empty for a
	// config that lists packages instead of modules.
	Module string
	// Key lists the primary key columns in key order. A scalar key type has
	// exactly one entry whose FieldName is empty.
	Key []KeyColumn
	// KeyIsStruct reports whether the key type argument is a struct.
	KeyIsStruct bool
	// Indexes are declared on the model rather than derived from a field, so
	// they can name any column -- including a trait column such as created_at,
	// which has no Go field to tag.
	Indexes []IndexDecl
	// EnumOwners names the enum types whose Values()/IsValid() helpers this
	// model's generated file declares. Two models of one package that share an
	// enum type must not declare the helpers two times, so assignEnumOwners
	// gives each enum type to exactly one model of the package. A nil map means
	// the model owns every enum it uses, which is the case when a caller emits
	// one model on its own.
	EnumOwners map[string]bool
}

type ModuleConfig struct {
	Name       string   `yaml:"name"`
	Packages   []string `yaml:"packages"`
	Migrations string   `yaml:"migrations"`
}

type OutputConfig struct {
	DB         string `yaml:"db"`
	Migrations string `yaml:"migrations"`
}

type RelationFieldInfo struct {
	Type        string // "has_many", "has_one", "belongs_to", "many_to_many"
	FK          string // foreign key column
	JoinTable   string // for many_to_many
	RefColumn   string // target FK column in pivot table (many-to-many)
	TargetModel string // target model name for foreign key resolution
}

type Schema struct {
	Tables []Table   `json:"tables"`
	Enums  []EnumDef `json:"enums,omitempty"`
}

type Table struct {
	Name string `json:"name"`
	// Checks lists the table's named CHECK constraints. It is filled by
	// introspection only: the generated schema carries a column's CHECK on the
	// column itself.
	Checks     []CheckConstraint `json:"checks,omitempty"`
	Columns    []Column          `json:"columns"`
	Indexes    []Index           `json:"indexes,omitempty"`
	PrimaryKey []string          `json:"primaryKey,omitempty"`

	// RenamedFrom is the table's previous name, declared by a renamed_from
	// marker on the model. It is a diff-time input only, never persisted: a
	// marker in the snapshot would make every future diff re-emit the rename.
	RenamedFrom string `json:"-"`
}