gorulesengine

package

Go to main page

Versions in this module

v1

v1.1.0

Jan 14, 2026

Changes in this version

type Almanac

+ func (a *Almanac) AddFailureEvent(event Event)

+ func (a *Almanac) AddSuccessEvent(event Event)

+ func (a *Almanac) GetFailureEvents() []Event

+ func (a *Almanac) GetSuccessEvents() []Event

type Condition

+ func Regex(fact string, pattern string) *Condition

type ConditionSet

+ func AllSets(sets ...ConditionSet) ConditionSet

+ func AnySets(sets ...ConditionSet) ConditionSet

+ func NoneSets(sets ...ConditionSet) ConditionSet

type ConditionType

+ const AllType

+ const AnyType

+ const NoneType

+ type EngineOption func(*Engine)

+ func WithPrioritySorting(o *SortRule) EngineOption

+ func WithoutPrioritySorting() EngineOption

+ type EventOutcome string

+ const EventOutcomeFailure

+ const EventOutcomeSuccess

type OperatorType

+ const OperatorContains

+ const OperatorEqual

+ const OperatorGreaterThan

+ const OperatorGreaterThanInclusive

+ const OperatorIn

+ const OperatorLessThan

+ const OperatorLessThanInclusive

+ const OperatorNotContains

+ const OperatorNotEqual

+ const OperatorNotIn

+ const OperatorRegex

+ type RegexOperator struct

+ func (o *RegexOperator) Evaluate(factValue interface{}, compareValue interface{}) (bool, error)

+ type RuleBuilder struct

+ func NewRuleBuilder() *RuleBuilder

+ func (rb *RuleBuilder) Build() *Rule

+ func (rb *RuleBuilder) WithConditions(node ConditionNode) *RuleBuilder

+ func (rb *RuleBuilder) WithEvent(eventType string, params map[string]interface{}) *RuleBuilder

+ func (rb *RuleBuilder) WithName(name string) *RuleBuilder

+ func (rb *RuleBuilder) WithOnFailure(callbackName string) *RuleBuilder

+ func (rb *RuleBuilder) WithOnSuccess(callbackName string) *RuleBuilder

+ func (rb *RuleBuilder) WithPriority(priority int) *RuleBuilder

+ type SortRule int

+ const SortByPriority

+ const SortDefault

+ const SortRuleASC

+ const SortRuleDESC

v1.0.0

Jan 13, 2026

Changes in this version

+ const AlmanacOptionKeyAllowUndefinedFacts

+ const ConstantFact

+ const DynamicFact

+ const EventFailure

+ const EventSuccess

+ const FactOptionKeyCache

+ const FactOptionKeyPriority

+ func DefaultPathResolver(value interface{}, path string) (interface{}, error)

+ func RegisterOperator(opType OperatorType, operator Operator)

+ type Almanac struct

+ func NewAlmanac(facts []*Fact, opts ...AlmanacOption) *Almanac

+ func (a *Almanac) AddEvent(event Event, outcome string)

+ func (a *Almanac) AddFact(id FactID, valueOrMethod interface{}, opts ...FactOption) error

+ func (a *Almanac) AddResult(result RuleResult)

+ func (a *Almanac) GetEvents(outcome string) []Event

+ func (a *Almanac) GetFactValue(factID FactID, params map[string]interface{}, path string) (interface{}, error)

+ func (a *Almanac) GetFactValueFromCache(factID FactID) (interface{}, bool)

+ func (a *Almanac) GetFacts() map[FactID]*Fact

+ func (a *Almanac) GetOptions() map[string]interface{}

+ func (a *Almanac) GetResults() []RuleResult

+ func (a *Almanac) TraversePath(data interface{}, path string) (interface{}, error)

+ type AlmanacError struct

+ Err error

+ Payload string

+ func (e *AlmanacError) Error() string

+ func (e *AlmanacError) Unwrap() error

+ type AlmanacOption func(*Almanac)

+ func AllowUndefinedFacts() AlmanacOption

+ type Condition struct

+ Fact FactID

+ Operator OperatorType

+ Params map[string]interface{}

+ Path string

+ Value interface{}

+ func (c *Condition) Evaluate(almanac *Almanac) (bool, error)

+ type ConditionError struct

+ Condition Condition

+ Err error

+ func (e *ConditionError) Error() string

+ func (e *ConditionError) Unwrap() error

+ type ConditionNode struct

+ Condition *Condition

+ SubSet *ConditionSet

+ func (n *ConditionNode) UnmarshalJSON(data []byte) error

+ type ConditionSet struct

+ All []ConditionNode

+ Any []ConditionNode

+ None []ConditionNode

+ func (cs *ConditionSet) Evaluate(almanac *Almanac) (bool, error)

+ type ConditionType string

+ const All

+ const Any

+ const None

+ type ContainsOperator struct

+ func (o *ContainsOperator) Evaluate(factValue interface{}, compareValue interface{}) (bool, error)

+ type Engine struct

+ func NewEngine() *Engine

+ func (e *Engine) AddFact(fact *Fact)

+ func (e *Engine) AddRule(rule *Rule)

+ func (e *Engine) On(eventType string, handler EventHandler)

+ func (e *Engine) OnFailure(handler EventHandler)

+ func (e *Engine) OnSuccess(handler EventHandler)

+ func (e *Engine) RegisterCallback(name string, handler EventHandler)

+ func (e *Engine) Run(almanac *Almanac) ([]RuleResult, error)

+ type EqualOperator struct

+ func (o *EqualOperator) Evaluate(factValue interface{}, compareValue interface{}) (bool, error)

+ type ErrorType string

+ const ErrAlmanac

+ const ErrCondition

+ const ErrEngine

+ const ErrEvent

+ const ErrFact

+ const ErrJSON

+ const ErrOperator

+ const ErrRule

+ type Event struct

+ Params map[string]interface{}

+ Type string

+ type EventHandler func(event Event, almanac *Almanac, ruleResult RuleResult) error

+ type EventHandlers struct

+ func (e *EventHandlers) GetHandlers(eventType string) []EventHandler

+ func (e *EventHandlers) RegisterHandler(eventType string, handler EventHandler)

+ type Fact struct

+ func NewFact(id FactID, valueOrMethod interface{}, opts ...FactOption) *Fact

+ func (f *Fact) Calculate(params map[string]interface{}) interface{}

+ func (f *Fact) FactType() string

+ func (f *Fact) GetCacheKey() (string, error)

+ func (f *Fact) GetOption(key string) (interface{}, bool)

+ func (f *Fact) HasOption(key string) bool

+ func (f *Fact) ID() FactID

+ func (f *Fact) IsDynamic() bool

+ func (f *Fact) ValueOrMethod() interface{}

+ type FactError struct

+ Err error

+ Fact Fact

+ func (e *FactError) Error() string

+ func (e *FactError) Unwrap() error

+ type FactID string

+ type FactOption func(*Fact)

+ func WithCache() FactOption

+ func WithPriority(priority int) FactOption

+ func WithoutCache() FactOption

+ type GreaterThanInclusiveOperator struct

+ func (o *GreaterThanInclusiveOperator) Evaluate(factValue interface{}, compareValue interface{}) (bool, error)

+ type GreaterThanOperator struct

+ func (o *GreaterThanOperator) Evaluate(factValue interface{}, compareValue interface{}) (bool, error)

+ type InOperator struct

+ func (o *InOperator) Evaluate(factValue interface{}, compareValue interface{}) (bool, error)

+ type LessThanInclusiveOperator struct

+ func (o *LessThanInclusiveOperator) Evaluate(factValue interface{}, compareValue interface{}) (bool, error)

+ type LessThanOperator struct

+ func (o *LessThanOperator) Evaluate(factValue interface{}, compareValue interface{}) (bool, error)

+ type NotContainsOperator struct

+ func (o *NotContainsOperator) Evaluate(factValue interface{}, compareValue interface{}) (bool, error)

+ type NotEqualOperator struct

+ func (o *NotEqualOperator) Evaluate(factValue interface{}, compareValue interface{}) (bool, error)

+ type NotInOperator struct

+ func (o *NotInOperator) Evaluate(factValue interface{}, compareValue interface{}) (bool, error)

+ type Operator interface

+ Evaluate func(factValue interface{}, compareValue interface{}) (bool, error)

+ func GetOperator(opType OperatorType) (Operator, error)

+ type OperatorError struct

+ CompareValue interface{}

+ Err error

+ Operator OperatorType

+ Value interface{}

+ func (e *OperatorError) Error() string

+ func (e *OperatorError) Unwrap() error

+ type OperatorType string

+ const Contains

+ const Equal

+ const GreaterThan

+ const GreaterThanInclusive

+ const In

+ const LessThan

+ const LessThanInclusive

+ const NotContains

+ const NotEqual

+ const NotIn

+ type PathResolver func(value interface{}, path string) (interface{}, error)

+ type Rule struct

+ Conditions ConditionSet

+ Event Event

+ Name string

+ OnFailure *string

+ OnSuccess *string

+ Priority int

+ type RuleEngineError struct

+ Err error

+ Msg string

+ Type ErrorType

+ func (e *RuleEngineError) Error() string

+ func (e *RuleEngineError) Unwrap() error

+ type RuleError struct

+ Err error

+ Rule Rule

+ func (e *RuleError) Error() string

+ func (e *RuleError) Unwrap() error

+ type RuleResult struct

+ Event Event

+ Result bool

+ Rule *Rule

Other modules containing this package

github.com/deadelus/go-rules-engine/v2

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL