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

	// Method is the index's declared access method/type (PostgreSQL's `USING
	// <method>`, MySQL's `USING BTREE|HASH`, T-SQL's CLUSTERED/NONCLUSTERED/
	// COLUMNSTORE kind, Prisma's `@@index(..., type: ...)`), lowercased at
	// every capture site so one convention holds across dialects. EMPTY means
	// "no access method declared in source" — the same empty-means-none
	// convention as Table.DBName and Trigger.ExecutesFunction — and is
	// deliberately NEVER defaulted to a guessed vocabulary word like "btree":
	// a consumer that needs a default applies its own, this field only
	// reports what the source actually said.
	//
	// A dialect that does not (yet) capture Method for a given statement
	// shape leaves it empty exactly like a dialect that never declared one —
	// the two are indistinguishable through this field alone (architecture/
	// two-classes-of-parser-blindness, "ceguera por omisión"); a provider's
	// own coverage manifest (internal/core/dbcoverage) is the place that
	// states which shapes it does and does not read.
	//
	// Prisma's `type:` vocabulary is NOT codefit-maintained: whatever value
	// the schema declares is captured verbatim (lowercased), never validated
	// against an assumed enum — codefit has not verified Prisma's own
	// documented set of accepted index types against every provider, so it
	// makes no claim here beyond "this is what the source said".
	Method string
}

type Partitioning struct {
	// Declaration is the partitioning clause VERBATIM from the user's own
	// DDL (modulo the identifier-quote canonicalization every SQL-DDL
	// statement goes through before reduction) — the structural analogue of
	// Unreduced.Text: parser internals never reach it. NON-EMPTY is the
	// authoritative "this table declares partitioning" answer.
	Declaration string

	// Strategy is the partitioning strategy word as the SOURCE spells it,
	// lowercased: "range", "list", "hash", "key", … EMPTY means the strategy
	// is not in the DDL read — either because the dialect does not state one
	// at the table (T-SQL puts it in the partition FUNCTION) or because the
	// clause was not decomposed. codefit does not maintain a closed
	// vocabulary here: whatever word follows PARTITION BY is captured.
	Strategy string

	// Scheme is the T-SQL partition scheme the table is created ON, name
	// only (normalized like any other identifier in the model). EMPTY on
	// dialects that have no partition schemes. codefit does NOT resolve the
	// scheme's range boundaries — only, when the DDL read also contains the
	// scheme's CREATE PARTITION FUNCTION, its Strategy.
	Scheme string

	// Key is the partition key as a list of plain COLUMN identifiers, in
	// source order. EMPTY when the source key is not a plain column list —
	// most commonly an expression (`PARTITION BY RANGE (YEAR(sold_on))`,
	// `PARTITION BY RANGE (extract(year from d))`). A partition key is never
	// GUESSED into columns: an expression decomposed by a column-list
	// splitter yields an invented column name ("YEAR(sold_on") that exists in
	// no table, which is exactly the fabrication class the completeness
	// contract cannot catch (it covers drops, not fabrications). When Key is
	// empty and Declaration is not, read Declaration.
	Key []string

	// Of names the PARENT table of a partition CHILD (PostgreSQL's `CREATE
	// TABLE c PARTITION OF p ...`), normalized like every other table
	// reference. EMPTY means the source did not declare this table as a
	// child — which is not proof that it is not one (see the type doc).
	Of string
}

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

	// Withheld carries declarations the parser READ correctly and
	// DELIBERATELY did not model (ADR 0043). It is a different fact from
	// Unreduced and deliberately a different channel: Unreduced means the
	// parser could not read a statement, Withheld means it could and chose,
	// for a stated reason, that the thing it read does not belong in the
	// schema codefit audits. Reporting a scoping decision as a parser failure
	// would misdescribe it in the opposite direction — it would tell an agent
	// codefit is blind where it is in fact seeing clearly.
	//
	// Withholding is never silent (CLAUDE.md, developer autonomy): it reaches
	// the agent through its own bounded trace in the per-scan note
	// (sensors/db.Result.Note), aggregated by reason, never one line per table.
	// It gates nothing per-table — there is no table to gate, because the
	// withheld declaration never entered the model.
	Withheld []Withheld
}

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

	// Partitioning is what this table's DDL declares about TABLE
	// partitioning. Its zero value means "the source codefit read declares
	// none" — see the type's own doc for what a consumer may and may not
	// conclude from that.
	Partitioning Partitioning

	// 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). The boundary still holds, but the class is SMALLER than when it was
	// written and is known to be reachable on ordinary real DDL, not only on
	// constructed input: ADR 0042 closed the missing-comma-before-a-table-level-
	// key fabrication (measured on three public warehouse corpora) with a
	// grammar-decided boundary rule in the reducer, plus a second instance where
	// an inline-constraint keyword was read out of a string literal. Each such
	// instance needs its own control at its own site — none of them can be caught
	// HERE.
	//
	// A DECLARED skip is NOT incompleteness: a form the parser recognizes and
	// deliberately does not model (CHECK, EXCLUDE, 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).
	//
	// A table's PARTITIONING clause is neither: it is now READ, into
	// Partitioning below. Reading it likewise leaves Complete=true, and for
	// the same reason — a partition key is not a primary key, an index or a
	// column, so even a partitioning form the reducer cannot decompose
	// cannot have hidden one. Partitioning reports its own partial reads
	// internally (Partitioning.Declaration) instead of demoting the table.
	//
	// 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
}

type Withheld struct {
	// Name is the declared name, as the source spells it, when the recognized
	// form puts it somewhere the parser knows. EMPTY means the form carries
	// none the parser can read faithfully — never a guess, and never
	// back-filled from the statement text.
	Name string
	// Text is the VERBATIM source statement — the user's own DDL, never
	// codefit's internals (the same measurement/diagnostics boundary
	// Unreduced.Text observes, ADR 0034 §2.8).
	Text string
	Pos  Pos
	// Reason is drawn from this package's closed WithheldReason vocabulary.
	Reason WithheldReason
}

type WithheldReason string