dsl

type EdgeInfo struct {
	From       string
	To         string
	Derivation bool
}

type EdgePattern struct {
	Alias  string
	Type   string
	VarMin int
	VarMax int
}

type EdgeTypeDecl struct {
	Name       string
	From       string
	To         string
	Derivation bool
}

type EnvPredicate struct {
	// NoteType is the note type the predicate is declared on.
	NoteType string
	// Kind is one of time_after | webhook | module_version | custom (§7.2).
	Kind string
	// Field is the date field a time_after predicate observes.
	Field string
	// Endpoint is the webhook predicate's endpoint name.
	Endpoint string
}

type EnvTrigger struct {
	// Kind selects which predicates fire (time_after | webhook).
	Kind string
	// Now is the clock observation a time_after trigger compares against. A
	// note is tagged when its predicate field is a date <= Now.
	Now time.Time
	// Endpoint is the webhook endpoint that fired (webhook kind). All notes
	// whose webhook predicate names this endpoint are tagged.
	Endpoint string
	// Targets optionally restricts the fire to specific note ids. When empty,
	// every note whose predicate matches the trigger is tagged; when set, only
	// the listed notes are tagged (a webhook fired for one policy, say). This
	// models the §8.4.1 declare_predicate_fired arg surface where a receiver
	// fires for a specific resource.
	Targets []string
	// TriggerID is recorded in the stale tag's `because` provenance list.
	TriggerID string
}

type FieldDecl struct {
	Name       string
	Type       string
	Derivation bool
}

type FieldInfo struct {
	Type       string
	RefType    string
	Derivation bool
}

type FieldRef struct {
	Alias string
	// Path is the field/ref selectors after the alias, in order. For
	// `c.stated_location.region` this is ["stated_location", "region"].
	Path []string
}

type FuncCall struct {
	Name string
	Args []ValueExpr
}

type MatchClause struct {
	Optional bool
	// Nodes are the node patterns in the clause: one (bare node) or two
	// (an edge hop a-[..]->b).
	Nodes []NodePattern
	// Edge is the edge pattern joining Nodes[0]→Nodes[1] when len(Nodes)==2;
	// nil for a bare single-node MATCH.
	Edge *EdgePattern
}

type NodePattern struct {
	Alias string
	Type  string
}

type NoteTypeDecl struct {
	Name   string
	Fields []FieldDecl
}

type Predicate struct {
	// Op is the comparison operator, one of the closed §5.1 set
	// {=, !=, <, <=, >, >=, IN} or the STARTS_WITH function form.
	Op string
	// Left is the field reference (alias + ref/field path) the predicate
	// filters on.
	Left FieldRef
	// Right is the value expression compared against Left.
	Right ValueExpr
	// Func names a WHERE-side function wrapping the whole predicate
	// (STARTS_WITH). Empty for a plain comparison.
	Func string
}

type Query struct {
	// Matches are the MATCH / OPTIONAL MATCH clauses in source order. The
	// first match binds the driving alias.
	Matches []MatchClause
	// Where are the conjuncted WHERE predicates (an empty slice means no
	// filter). v1 has no OR; predicates AND together.
	Where []Predicate
	// Returns are the RETURN items in source order.
	Returns []ReturnItem
	// contains filtered or unexported fields
}

type ReturnItem struct {
	// Ref is the field reference when the item is a plain projection; its
	// Alias is empty when the item is a pure intrinsic (hop_count/count).
	Ref FieldRef
	// Func is the aggregate/intrinsic function name (count, min, max,
	// hop_count, coalesce) or empty for a plain field projection.
	Func string
	// FuncArgs are the arguments to Func (e.g. min(c.field) has one ref arg).
	FuncArgs []ReturnItem
	// Alias is the output column name. Defaults to the source text when the
	// query omits an explicit AS.
	Alias string
}

type SchemaInfo struct {
	// NoteFields maps note-type → field name → field metadata.
	NoteFields map[string]map[string]FieldInfo
	// Edges maps edge-type → endpoints/derivation metadata.
	Edges map[string]EdgeInfo
	// MaxDepth bounds variable-length edge patterns (§4 / §5.1). A query whose
	// `*1..N` exceeds MaxDepth is rejected (T37). Zero means "unset" and the
	// check is skipped (Parse without a declared bound).
	MaxDepth int
}

type ValueExpr struct {
	// Param is the parameter name (without the leading $) when this is a param
	// reference.
	Param string
	// Literal holds a string/number/bool literal value.
	Literal any
	// IsLiteral disambiguates a nil/zero Literal from "not a literal".
	IsLiteral bool
	// Call is a coalesce(...) call over params/literals (the only WHERE-side
	// allowed function on the value side, §5.1.1). nil when not a call.
	Call *FuncCall
}