Question: How do I specify a rule which compares two facts?

[vivekkodira1]

Ex: Say the facts are
{ "avg_def_density_tolerance_hit": "yes", "tot_developers": 900, "tot_defects": 1003, "open_stories": 12 }
And I want to write a rule that will pass if tot_defects > open_stories

Suggestion: If this is not easy to implement or you'd rather not support it, please consider enhancing the addOperator method to pass in the complete rule and all the facts: that way others can add the logic necessary.

[CacheControl]

@vivekkodira1 I'm a little surprised no one has brought this up to me before! This is a perfectly reasonable thing to want to do. Unfortunately in its current state, this is not well supported. In the immediate term, you'd have to store the two facts inside the params option, and essentially do the comparison yourself within the fact definition:

let rule = {
  conditions: {
    all: [{
      fact: 'fact-comparison',  // a fact for comparing other facts
      operator: 'equal',  // operator and value are just here to assert whether the result was truthy/falsey
      value: true,
      params: {
         fact1: 'tot_defects',  // first fact to compare
         fact2: 'open_stories', // second fact to compare
         operator: 'greaterThan' // how to compare the facts
      }
    }]
  },
  event: {/* ... */}
}
engine.addRule(rule)

engine.addFact('fact-comparison', function (params, almanac) {
  // retrieve the fact values from each of the facts referenced in "params"
  return Promise.all([almanac.factValue(params.fact1), almanac.factValue(params.fact2)])
    .then(factValues => {
      let fact1Value = factValues[0] // in your example, would return 1003
      let fact2Value = factValues[1] // in your example, would return 12
      let operator = params.operator // "greaterThan"
      // each engine stores a registry of operators, which can be called to test one value against another
      // just make sure to stick to the official operator names inside "params"; "equal", "notEqual", etc
      return engine.operators.get(operator).evaluate(fact1Value, fact2Value) // returns true
    })
})

If this looks like a hack, it's because it is 😄 However it should at least allow you to move forward.

[CacheControl]

Thinking about a longer term solution that doesn't require so much customization, I'd probably lean towards allowing the value property to contain a fact. This would allow the case above to look like:

let rule = {
  conditions: {
    all: [{
      fact: 'tot_defects',
      operator: 'greaterThan',
      value: {
         fact: 'open_stories'   // the "params" and "path" fact modifiers would also be supported here
      }
    }]
  },
  event: {/* ... */}
}
engine.addRule(rule)

I'm not sure how large of a refactor this is, so I can't provide an eta. For now I'll flag this as a feature request and place is on the short-term roadmap. Please do let me know if you have any feedback on the proposed solution above, or an alternative approach. Thanks for bringing this to my attention!

[vivekkodira1]

@CacheControl thank you. Will try the hack and also give you feedback.

[arsalans]

@CacheControl So I am not sure if there is a voting feature here in github but I would like to give this feature request a thumbs up 👍

Basically, one reason for using a rules engine is to have simplicity in your rules where the logic is not hidden behind huge lines of code in javascript. So in my mind, this qualifies as a basic requirement.

[CacheControl]

Yep, this is high up my the radar, just need to find some time to implement it.

[jgoux]

I really like the second approach you suggested @CacheControl !
I just hit the need for a fact comparison too. :)

[CacheControl]

This has been implemented and published in 1.5.0. Documentation can be found here. An example has been added here.

I will close this issue for now, please open any defects related to this feature as a new, separate issue.

[taurenk]

@CacheControl I think this feature broke existing functionality. For example, this rule/fact worked:

// Fact
let fact = {x: {y:1}, a:2};
let rule = {
    "conditions" : {
        "all" : [ 
            {
                "fact" : "x",
                "path" : ".y",
                "operator" : "equal",
                "value" : 1
            }
        ]
    },
    "event" : { }
};

now path does not seem to work. Can you confirm?

[CacheControl]

@taurenk thanks for reporting this, I've published a bug fix in 1.5.1. Looks like there was a gap in our test suite, which has now been remedied. Please let me know if you run in to any other issues.

[taurenk]

Thanks for the quick fix, @CacheControl. Everything seems to be working great now.

[sk8Guerra]

I see this issue was open in 2016. I've used the hack to compare the two facts and works great. But will the library support this? O we will keep just with this workaround?