schema

type Arg struct {
	Name    string
	Type    string
	Default string // SDL literal, empty for none
}

type Builder struct {
	Catalog *introspect.Catalog
	Inflect inflect.Next
	Options Options
	Objects map[string]*Object
	Inputs  map[string]*Input
	Enums   map[string]*Enum
	Scalars []string
	// Query/Mutation are the root objects (also present in Objects).
	Query    *Object
	Mutation *Object

	// TypeForTable maps "schema.table" to the generated object type name.
	TypeForTable map[string]string
	// TypeForComposite maps "schema.type" to the generated object type name.
	TypeForComposite map[string]string
	// InputForComposite maps "schema.type" to the generated input type name.
	InputForComposite map[string]string
	// contains filtered or unexported fields
}

type Built struct {
	Schema       *ast.Schema
	SDL          string
	Meta         Meta
	Catalog      *introspect.Catalog
	TypeForTable map[string]string
	// TableForType maps object type name -> catalog table (node() dispatch).
	TableForType map[string]*introspect.Table
	// OrderBy maps enum type name -> value name -> (column, desc).
	OrderBy map[string]map[string]OrderSpec
	// EnumValues maps enum type name -> GraphQL value -> pg value.
	EnumValues map[string]map[string]string
	// EnumTypeForPG maps "typeschema.typename" -> GraphQL enum type name.
	EnumTypeForPG map[string]string
	// CompositeTypeForPG maps "typeschema.typename" -> GraphQL object type name.
	CompositeTypeForPG map[string]string
	// CompositeInputForPG maps "typeschema.typename" -> GraphQL input type name.
	CompositeInputForPG map[string]string
	// InputColumns maps input type name -> field name -> column name.
	InputColumns map[string]map[string]string
	// FilterRelations maps filter input type name -> field name -> relation
	// binding (advanced-filters plugin; empty otherwise).
	FilterRelations map[string]map[string]*FilterRelation
	// FilterComputed maps filter input type name -> field name -> the
	// computed-column function backing it (advanced-filters plugin).
	FilterComputed map[string]map[string]*introspect.Function
}

type Enum struct {
	Name        string
	Description string
	Values      []EnumValue
}

type EnumValue struct {
	Name        string
	Description string
	// Column/Desc back orderBy enum values.
	Column string
	Desc   bool
	// Computed backs orderBy enum values sorting by a computed column
	// (advanced-filters): a row-type function instead of a plain column.
	Computed *introspect.Function
	// PGValue backs catalog enum values.
	PGValue string
}

type Field struct {
	Name        string
	Type        string // SDL type reference, e.g. "String!", "[User!]!"
	Description string
	// Deprecated carries the @deprecated(reason:) directive when non-empty.
	Deprecated string
	Args       []Arg
	Meta       *FieldMeta
}

type FieldKind string

type FieldMeta struct {
	Kind       FieldKind
	Table      *introspect.Table      // owning/target table
	Column     *introspect.Column     // for KindColumn
	KeyColumns []string               // lookup / update / delete key
	FK         *introspect.ForeignKey // for relations
	Function   *introspect.Function
	// Nested carries plugin-defined payload (e.g. nested-mutations input shape).
	Nested map[string]any
}

type FilterRelation struct {
	// Forward: the FK lives on the filtered table and points at Table
	// (many-to-one); the field takes Table's filter directly. Otherwise the
	// FK lives on Table and points back at the filtered table (one-to-many);
	// the field takes a {some|none|every} wrapper over Table's filter.
	Forward bool
	FK      *introspect.ForeignKey
	// Table is the related table the EXISTS subquery scans.
	Table *introspect.Table
	// FilterType is Table's <Type>Filter input name.
	FilterType string
}

type Input struct {
	Name        string
	Description string
	Fields      []*InputField
}

type InputField struct {
	Name        string
	Type        string
	Description string
	Default     string
	// Column links the input field to a table column for mutation compilation.
	Column string
	// Relation marks a relation filter field (advanced-filters); the compiler
	// turns it into an EXISTS subquery over the related table.
	Relation *FilterRelation
	// Computed marks a computed-column filter field (advanced-filters): the
	// bound row-type function is called on the current row.
	Computed *introspect.Function
	// Nested marks plugin-added nested-input fields (e.g. nested mutations).
	Nested map[string]any
}

type Meta map[string]map[string]*FieldMeta

type Object struct {
	Name        string
	Description string
	Fields      []*Field
	// Interfaces lists interface names this object implements.
	Interfaces []string
	// IsInterface renders the type as `interface X` instead of `type X`.
	IsInterface bool
}

type Options struct {
	FilterIndexedOnly bool
	// AllowColumns lists extra filterable columns per "schema.table".
	AllowColumns map[string][]string
	// Functions exposes PostgreSQL functions as custom queries/mutations.
	Functions bool
	Logger    *slog.Logger
}

type OrderSpec struct {
	Column string
	Desc   bool
	// Computed orders by a row-type function instead of Column.
	Computed *introspect.Function
}