db

type Body struct {
	Text     string
	Complete bool
	Note     string
}

type Column struct {
	Name string
	// DBName is the real column name in the database when remapped via @map. EMPTY
	// means "no remap" (fall back to Name) — not defaulted to Name, same rationale
	// as Table.DBName.
	DBName   string
	Pos      Pos
	Type     Type
	RawType  string
	Nullable bool
	List     bool // multivalued / array, e.g. Prisma String[] (DB-002)
}

type ForeignKey struct {
	Pos        Pos
	Columns    []string
	RefTable   string
	RefColumns []string
}

type Index struct {
	Pos     Pos
	Columns []string // composite supported (DB-013)
	Unique  bool
}

type Pos struct {
	File string
	Line int
}

type Procedure struct {
	Name string
	Pos  Pos
	Body Body
}

type Reason string

type Schema struct {
	Tables     []Table
	Views      []View      // OLTP surface; not filled by the Prisma parser
	Procedures []Procedure // idem
	Triggers   []Trigger   // idem

	// Unreduced carries statements the parser recognized as table-affecting
	// (e.g. "alter table ...") but could not attribute to any specific table
	// (a regex miss on the table name itself) — design §2, drop site 2. It
	// gates NOTHING per-table (there is no table to gate); it surfaces only in
	// the per-scan completeness inventory (sensors/db.Result.Note).
	Unreduced []Unreduced
}

type Table struct {
	Name string
	// DBName is the real table name in the database when remapped via @@map (or the
	// SQL identifier when it differs from the model name). EMPTY means "no remap" —
	// a consumer falls back to Name; it is deliberately NOT defaulted to Name, so a
	// rule can tell an explicit remap from none. FKs/indexes reference by model
	// name, not DBName (ADR 0014).
	DBName      string
	Pos         Pos
	Columns     []Column
	PrimaryKey  []string // column names; empty = no PK (DB-050); len>1 = composite
	ForeignKeys []ForeignKey
	Indexes     []Index

	// Complete=false means the parser met at least one statement affecting
	// this table that it could NOT reduce, and could not rule out that the
	// statement declared a key, index or column. A rule that concludes from
	// ABSENCE MUST treat Complete==false as grounds to abstain or downgrade to
	// a surface item, never to emit a deterministic finding — ADR 0004 made
	// mechanical for the STRUCTURAL model exactly as ADR 0025 made it
	// mechanical for routine bodies (Body.Complete).
	//
	// BOUNDARY, so the contract does not over-promise: Complete covers DROPS,
	// not FABRICATIONS. A reducer that believes it succeeded while inventing
	// data reports Complete=true; that class needs its own control (design
	// §8e).
	//
	// A DECLARED skip is NOT incompleteness: a form the parser recognizes and
	// deliberately does not model (CHECK, EXCLUDE, PARTITION, ALTER COLUMN,
	// RENAME, OWNER, ...) is known not to be a key/index/column and leaves
	// Complete=true (ADR 0018's declared subset, made machine-visible).
	//
	// Zero value is false (fail-closed, design §1-D1b): a table nobody
	// explicitly proved complete is unproven by default, never trustworthy by
	// accident. Every construction site MUST set this explicitly.
	Complete bool

	// Note is WHY, drawn from this package's closed Reason* vocabulary —
	// never provider prose. A provider can only SELECT a reason and QUOTE the
	// user's own source (Unreduced[].Text); it has no channel through which
	// parser-internal diagnostics (a function name, a dispatch branch, a
	// regex) can reach scan output (ADR 0034's measurement/diagnostics
	// boundary). Deduplicated by reason: two drops for the same reason add one
	// Note entry, not two.
	Note string

	// Unreduced is the raw statement text the parser could not reduce, kept
	// VERBATIM with its origin so the agent can read the SOURCE itself — the
	// structural analogue of Body.Text. This is the USER's DDL, never
	// codefit's internals.
	Unreduced []Unreduced
}

type Trigger struct {
	Name  string
	Pos   Pos
	Table string
	Body  Body

	// ExecutesFunction is the name of the function/procedure this trigger
	// invokes, when the dialect expresses that as a distinct name in the
	// trigger statement (PostgreSQL: "... EXECUTE FUNCTION|PROCEDURE fn()").
	// EMPTY means the dialect embeds the trigger's logic directly in Body
	// instead (MySQL, T-SQL), or the executed routine's name could not be
	// parsed. This is the trigger→function LINK (Phase 2.2, Unit A2,
	// architecture/pg-trigger-body-link): a PostgreSQL trigger carries no
	// inline body of its own — the logic lives in the named function, which a
	// consumer resolves via Schema.ExecutedProcedure(t), never by re-deriving
	// completeness on the trigger's own (bodyless) statement.
	ExecutesFunction string
}

type Type string

type Unreduced struct {
	Text string
	Pos  Pos
}

type View struct {
	Name string
	Pos  Pos
	Body Body
}