entity

type Action uint8

type Attribute struct {
	Name        string
	Alias       string
	Description string
	Domain      Domain
	Excluded    bool   // true removes the column from all responses (field projection)
	Mask        string // optional mask rule name (see mask package)
}

type Cascade struct {
	// Schema and Table name the referencing relation; Relation is its
	// relation key and Entity the entity exposing it ("" when none does),
	// both set at assembly.
	Schema   string
	Table    string
	Relation string
	Entity   string
	// Columns are the referenced columns of this relation; ForeignColumns
	// the referencing columns of the other, in the same order.
	Columns        []string
	ForeignColumns []string
	OnDelete       string
	OnUpdate       string
}

type Domain struct {
	Type     string
	Nullable bool
	// Default reports that the database supplies a value when an insert
	// omits the column (a default expression, a sequence, an identity BY
	// DEFAULT or auto_increment).
	Default bool
	// Generated reports that the database computes the value (a generated
	// column or an identity ALWAYS): the column cannot be written.
	Generated bool
	// AutoIncrement reports a value taken from a sequence on insert.
	AutoIncrement bool
}

type Entity struct {
	// Name identifies the entity: its canonical ID (see ID) when Local is
	// set, which every reference inside the gateway uses.
	Name string
	// Local is the configured name, unique within its datasource and schema;
	// empty when Name is not namespaced.
	Local       string
	Source      string
	DataSource  string
	Schema      string
	Description string
	Kind        Kind
	Attributes  []Attribute
	Keys        []Key
	ForeignKeys []ForeignKey
	// Indexes are the table's indexes as introspection reports them, for
	// administrators to see; the database plans access paths, not the
	// gateway. The unique ones are also Keys.
	Indexes     []Index
	Role        RoleAccess
	FieldAccess FieldAccess
	MCP         MCPFlags
	RowPolicies RowPolicies
	// TenantPolicy is ANDed for every principal and never merged across
	// grants; nil means the entity has no tenant boundary.
	TenantPolicy relalg.Predicate
	Relations    []Relationship
	// Derived marks a relation whose data comes from other relations (a view,
	// a materialized view or a foreign table): a write to any table of its
	// datasource may change it.
	Derived bool
	// Relation identifies the physical relation (set at assembly, see
	// RelationKey); at most one entity exposes a relation.
	Relation string
	// Affects lists the entities a procedure writes; empty means unknown.
	Affects []string
	// Cascades are the foreign keys of other relations whose referential
	// actions write their rows when this entity's rows are deleted or their
	// referenced columns updated (I-6).
	Cascades []Cascade
	// AllowCascade admits such writes without checking the caller's
	// permissions on the cascaded entities.
	AllowCascade bool
	// SideEffects reports triggers or rules on the relation: a write may
	// change other relations of the datasource.
	SideEffects bool
	// Params is the ordered list of formal parameter names for a KindProcedure
	// entity. execute_entity binds a caller's named args to positional CALL
	// placeholders in this exact order; a stored procedure whose params are not
	// declared cannot be executed (fail-closed) since positional binding would
	// otherwise be guesswork.
	Params []string
}

type FieldAccess map[string]FieldPermissions

type FieldPermissions struct {
	Read  []string
	Write []string
}

type ForeignKey struct {
	Name    string
	Columns []string
	// RefSchema is the referenced relation's schema; it may differ from the
	// referencing table's.
	RefSchema   string
	RefRelation string
	RefColumns  []string
	// OnDelete and OnUpdate are the referential actions: one of the FK*
	// constants, empty when the database reports none.
	OnDelete string
	OnUpdate string
}

type Index struct {
	Name string
	// Method is the database's name for the index structure, lower-cased:
	// for example btree, hash, gin, gist, brin or spgist on PostgreSQL, and
	// btree, hash, fulltext or spatial on MySQL and OceanBase.
	Method string
	// Parts are the key parts in order: a column, a column prefix such as
	// title(20), or an expression as the database prints it. Parts the
	// database does not report (OceanBase's full-text and spatial indexes)
	// are left out.
	Parts   []string
	Unique  bool
	Primary bool
	// Where is the predicate of a partial index.
	Where string
}

type Key struct {
	Name    string
	Columns []string
	Primary bool
	// Declared marks a key the database does not guarantee, configured on a
	// view or foreign table: it serves reads, never the write-safety check.
	Declared bool
	// Deferrable reports a constraint checked at commit: inside a
	// transaction it may be violated, so it identifies no row there.
	Deferrable bool
	// Reason is empty for a key that identifies at most one row.
	Reason string
}

type Kind uint8

type MCPFlags struct {
	DMLTools         bool // expose the seven DML tools for this entity
	CustomTool       bool // register a stored procedure as a named tool
	TrustedProcedure bool // procedure passed explicit DBA cost/safety review
}

type Registry struct {
	// contains filtered or unexported fields
}

type Relationship struct {
	Name   string
	Target string
	// Cardinality is one of Cardinalities: how many target rows a row has.
	Cardinality string
	JoinOn      map[string]string // this field -> target field
}

type Resolved struct {
	Entity     Entity
	Attributes []Attribute
}

type RoleAccess map[Action][]string

type RowPolicies map[string]relalg.Predicate