"Not Equal to Nil" kind of check before executing expressions

[alok87]

hey we wrote a simple rule engine using expr (with when and then)

Problem:
Our users specify rules like show offers if order.Amount > 500 and product.Category = xyz. But at the time offer discovery sometimes order Amount is not available or sometimes product.Category is also not available. But we want to show the offers to those users. So we want to write an expression like:

(order.Amount > 500 || order.Amount == 0) &&
(product.Category == xyz || product.Category == "")  

But doing this for every fact fields (facts are order and product here) is adding un-necessary complexity in writing such rules. As users in API just specify conditions around fact's field. Order's and product's fields. And we make an expression from it internally.

Do you have any suggestion around this problem's solution with expr?

[antonmedv]

So Amount and Category of Product{} struct can be uninitialized and have zero values.

So in case of zero value Amount will be equal to 0, and condition order.Amount > 500 will be false.

If users write a condition in the form of:

order.Amount > 500 and product.Category = xyz

And expect what both parts gonna be met. Not sure if it is a good idea to return true from false && true condition. I guest user need to explicitly decide what to do if order not present. Maybe you can add some helpers for it:

hasOrder() ? (order.Amount > 500 and product.Category = xyz) : true /* ok without order */

Or just ose OR:

order.Amount > 500 or product.Category = xyz

What are your thoughts?

[antonmedv]

Another check I'm planning to add to expr is nil checks: user will be asked to make sure what avalue is not nil before processing.

err: order is potentialy nil
| order.Amount > 500 or product.Category = xyz
|......^

And users can ckange expression to something like this:

order != nil ? order.Amount > 500 : true

Or to:

order?.Amount ?? 999 > 500

[alok87]

@antonmedv let me try to tell it from API side of this.

Offer Creation

Offer is created with expressions like this. At the time of discovery we need to show all offers based on the facts passed at the time of offer discovery, but at the time of availment we need to mandatory require all order and product data to say it can be availed or not.

So at present we have to create offer like this:

offer:
    metadata:
    spec:
          eligiblity_rule:
                   discovery_of_offer:
                             (order.amount > 500 || order.amount == 0) &&
                             (product.category == xyz || product.category == "") 
                    availment_of_offer:
                             order.amount > 500 && product.category == xyz

Offer Discovery & Offer Availment:

API would be like: GET /eligible_offers and also validate(Avail) has same spec mostly POST /avail/<offer_id>

facts:
     order: 
        amount: 501
      product:
         category: xyz

In this API order and product if passed we should filter the offers for them else not. Hence the || checks in disovery_of_offer rule.

This is also required because at the time of discovery of offers, all facts are not present. So we do not want to filter out those offers for users.

The nil check idea you suggested would help.

[antonmedv]

Another thing you can use right now is Patcher. You can modify users requests and add corresponding || automatically.

[alok87]

What is Patcher?
We were thinking of doing that after getting API request to convert it into expressions with ||, but we have to do that for every field of every object.

[antonmedv]

https://expr.medv.io/docs/Visitor-and-Patch

[alok87]

@antonmedv thanks, let us check this.

[alok87]

@antonmedv we want clients only to do own the logic of writing the expressions and not want to manipulate it with patch. Nil check would help us.

[antonmedv]

Another thing is how you unmarshal things. For example what to do if order not present.