constraints

type CardinalityConstraint struct {
	NodeLabel string    // Label to apply constraint to
	EdgeType  string    // Type of edge (empty = any type)
	Direction Direction // Direction of edges to count
	Min       int       // Minimum number of edges (0 = optional)
	Max       int       // Maximum number of edges (0 = unlimited)
}

type Constraint interface {
	// Validate checks the constraint against the graph
	// Returns a list of violations (empty if valid)
	Validate(graph GraphReader) ([]Violation, error)

	// Name returns a human-readable name for the constraint
	Name() string
}

type Direction int

type GraphReader interface {
	// Node operations
	GetNode(nodeID uint64) (*storage.Node, error)
	// GetAllNodesAcrossTenants returns every node from every tenant.
	// Constraint validation currently runs across all tenants — for
	// uniqueness/cardinality constraints, this means a violation in one
	// tenant fires even when the duplicate lives in a different tenant.
	// Per-tenant constraint validation is a separate follow-up; the
	// audit-A3b rename surfaces the cross-tenant semantic at the call
	// site so the limitation is visible in code review.
	GetAllNodesAcrossTenants() []*storage.Node
	FindNodesByLabelAcrossTenants(label string) ([]*storage.Node, error)
	GetAllLabels() []string

	// Edge operations
	GetEdge(edgeID uint64) (*storage.Edge, error)
	FindEdgesByTypeAcrossTenants(edgeType string) ([]*storage.Edge, error)
	GetOutgoingEdges(nodeID uint64) ([]*storage.Edge, error)
	GetIncomingEdges(nodeID uint64) ([]*storage.Edge, error)
}

type PropertyConstraint struct {
	NodeLabel    string            // Label to apply constraint to
	PropertyName string            // Name of the property
	Type         storage.ValueType // Expected type (0 = any type)
	Required     bool              // Whether property must exist
	Min          *storage.Value    // Minimum value (for int/float)
	Max          *storage.Value    // Maximum value (for int/float)
}

type Severity int

type UniqueEdgeConstraint struct {
	// EdgeType is the edge type to check for uniqueness
	EdgeType string

	// SourceLabel optionally restricts to edges from nodes with this label
	SourceLabel string

	// TargetLabel optionally restricts to edges to nodes with this label
	TargetLabel string
}

type UniquePropertyConstraint struct {
	// PropertyKey is the property that must be unique
	PropertyKey string

	// NodeLabel optionally restricts the constraint to nodes with this label.
	// If empty and Scope is ScopeLabel, the constraint validates per-label uniqueness.
	// If set and Scope is ScopeLabel, only nodes with this label are checked.
	NodeLabel string

	// Scope determines whether uniqueness is global or per-label
	Scope UniqueScope
}

type UniqueScope int

type ValidationResult struct {
	Valid      bool        // True if no violations found
	Violations []Violation // List of all violations
	CheckedAt  time.Time   // When validation was performed
}

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

type Violation struct {
	Type       ViolationType
	Severity   Severity
	NodeID     *uint64
	EdgeID     *uint64
	Constraint string
	Message    string
	Details    map[string]any
}

type ViolationType int