diegoholiveira / jsonlogic Goto Github PK

To Reproduce

1. Run the following code

package main

import (
	"bytes"
	"fmt"
	"strings"

	"github.com/diegoholiveira/jsonlogic/v3"
)

func main() {
	logic := strings.NewReader(`{"<": ["abc", 3]}`)
	data := strings.NewReader(`{}`)

	var result bytes.Buffer

	jsonlogic.Apply(logic, data, &result)

	fmt.Println(result.String())
}

Expected
false

"abc" is not less than 3.
Using the same logic / data here https://jsonlogic.com/play.html will return the expected result.

Actual
true

Step-by-step

1. I took the first example from the readme.
2. Created a module: go mod init myNewProject
3. Edited my go.mod

module myNewProject

go 1.13

require (
        github.com/diegoholiveira/jsonlogic/v2 v2.5.2
        github.com/mitchellh/copystructure v1.0.0 // indirect
)

4. Then: go get

require github.com/diegoholiveira/jsonlogic: version "v2.5.2" invalid: module contains a go.mod file, so major version must be compatible: should be v0 or v1, not v2

Possible solutions

• change your module name in go.mod to github.com/diegoholiveira/jsonlogic/v2
  • But you have to delete tag that don't begin with v
• or change to /v3 and create a new v3.0.0 tag.

func TestGetVarArray(t *testing.T){
	rule := strings.NewReader(`{
          "and": [
            {
              "==": [
                { "var" : "tempNumbers.0"},
               "123-456"
              ]
            },
            {
              "==": [
                { "var" : "tempNumbers.1"},
                "234-567"
              ]
            }
          ]
        }`)

	data := strings.NewReader(`{
          "tempNumbers": [
            "123-456",
            "234-567",
            "345-678"
          ]
        }`)

	var result bytes.Buffer

	jsonlogic.Apply(rule, data, &result)

	fmt.Println(result.String())

}

this is the stack trace :

github.com/diegoholiveira/jsonlogic.getVar(0x74af80, 0xc000182d60, 0x75c0e0, 0xc000185620, 0x100000000754da0, 0xffffffffffffffff)
/home/nicholas/Desktop/clone/golang-body-parser/src/vendor/github.com/diegoholiveira/jsonlogic/vars.go:91 +0x725
github.com/diegoholiveira/jsonlogic.operation(0xc000025f36, 0x3, 0x74af80, 0xc000182d60, 0x75c0e0, 0xc000185620, 0x400, 0x7f0e4ca68f00)
/home/nicholas/Desktop/clone/golang-body-parser/src/vendor/github.com/diegoholiveira/jsonlogic/jsonlogic.go:540 +0x1105
github.com/diegoholiveira/jsonlogic.apply(0x75c0e0, 0xc000185590, 0x75c0e0, 0xc000185620, 0x194, 0x4007f0e73595768)
/home/nicholas/Desktop/clone/golang-body-parser/src/vendor/github.com/diegoholiveira/jsonlogic/jsonlogic.go:708 +0x1dc
github.com/diegoholiveira/jsonlogic.parseValues(0x7465e0, 0xc00019ac20, 0x75c0e0, 0xc000185620, 0x0, 0x0)
/home/nicholas/Desktop/clone/golang-body-parser/src/vendor/github.com/diegoholiveira/jsonlogic/jsonlogic.go:674 +0x2ac
github.com/diegoholiveira/jsonlogic.apply(0x75c0e0, 0xc000185560, 0x75c0e0, 0xc000185620, 0xc000053d90, 0x30000000054128a)
/home/nicholas/Desktop/clone/golang-body-parser/src/vendor/github.com/diegoholiveira/jsonlogic/jsonlogic.go:708 +0x196
github.com/diegoholiveira/jsonlogic.parseValues(0x7465e0, 0xc00019aca0, 0x75c0e0, 0xc000185620, 0x0, 0xc000132660)
/home/nicholas/Desktop/clone/golang-body-parser/src/vendor/github.com/diegoholiveira/jsonlogic/jsonlogic.go:674 +0x2ac
github.com/diegoholiveira/jsonlogic.apply(0x75c0e0, 0xc000185530, 0x75c0e0, 0xc000185620, 0x0, 0x8d7308)
/home/nicholas/Desktop/clone/golang-body-parser/src/vendor/github.com/diegoholiveira/jsonlogic/jsonlogic.go:708 +0x196
github.com/diegoholiveira/jsonlogic.Apply(0x827320, 0xc00019abc0, 0x827320, 0xc00019abe0, 0x826c20, 0xc000185500, 0x2202e31c0000000f, 0x6071bd75)
/home/nicholas/Desktop/clone/golang-body-parser/src/vendor/github.com/diegoholiveira/jsonlogic/jsonlogic.go:736 +0x1ec
github.com/nicholasanthonys/Golang-Body-Parser/test.TestGetVarArray(0xc000001b00)
/home/nicholas/Desktop/clone/golang-body-parser/src/test/clogic_test.go:169 +0xee
testing.tRunner(0xc000001b00, 0x7d5518)
/home/nicholas/go1.15.5/src/testing/testing.go:1123 +0xef
created by testing.(*T).Run
/home/nicholas/go1.15.5/src/testing/testing.go:1168 +0x2b3

Can you help me with this ?

Please refer to the old issue for more details.

#28

Hello,

I seem to hit a case where the library is returning an error when a property, that is in the "logic" but not in the "data". Below is an example program to reproduce the issue.

package main

import (
	"bytes"
	"fmt"
	"os"
	"strings"

	"github.com/diegoholiveira/jsonlogic"
)

func main() {
	logic := strings.NewReader(`{"logic":{"and":[{"!":{"var":"var_not_in_data"}}]}}`)
	data := strings.NewReader(`{"some_key": "value"}`)

	var result bytes.Buffer
	err := jsonlogic.Apply(logic, data, &result)
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}

	fmt.Println(result.String())
}

And here's the output:

interface conversion: interface {} is nil, not []interface {}

Process finished with exit code 1

If I add the var_not_in_data to the data object it evaluates the expression correctly.

Edit Note: It used to panic with version 2, it just returns the error now with v3

rule = {"and":[{"in":[{"var":"flow"},["BRAND"]]},{"or":[{"if":[{"missing":["gender"]},true,false]},{"some":[{"var":"gender"},{"==":[{"var":null},"men"]}]}]}]}

data= {"category":["sneakers"],"flow":"BRAND","gender":["men"],"market":"US"}

err = jsonlogic.Apply(bytes.NewReader(rule), bytes.NewReader(data), &resultBuffer)

getting error in this case
interface conversion: interface {} is map[string]interface {}, not string

but this case pass in playground/ javascript client

Hey @diegoholiveira

I'm having an issue when using map operation. Basically I'm trying to iterate over an array of arrays, and then using the in operation to evaluate for every given array if the passed argument is present in each one. My rule looks like this:

{
  "map": [
    {
      "var": "listOfLists"
    },
    {
      "in": [
        "item_a",
        {
          "var": ""
        }
      ]
    }
  ]
}

And the input data:

{
  "listOfLists": [
    ["item_a", "item_b", "item_c"],
    ["item_b", "item_c"],
    ["item_a", "item_c"]
  ]
}

So basically I expect to get an array of booleans as output, that informs me for every list if item_a was present:

[
    true,
    false,
    true
]

But for some reason, this is what I'm getting:

[
    true,
    true
]

It looks like it's ignoring false values, showing only the true ones. For the record, I ran the test in the JsonLogic site and I get the result I was expecting, so I think It could be an issue with the map implementation.
Thanks!

Max starts with "SmallestNonzeroFloat64" which is the smallest positive, non-zero value. So max:[0,0], max:[-1,0], max:[-3,-2] and etc. will all get incorrect answer. Also, min is correctly start with maximum value but min:[] return very large number make no sense. It should return null or error *spec in jsonlogic website return null for empty or if it contains not-numeric-castable.
So I think you should start with first found number. Then compare following number with the first one, not some made-up value. Return null for not-numeric-castable/empty input if want to follow jsonlogic.

Hi. I need validateJsonLogic in my code because I decode a bunch of rules from a big JSON structure. And I want to check them when they are already interface{}.

Please export it

A rule map containing more than 1 key should count as a primitive value and be returned by calling Apply. However, this is not currently the case in this package. Instead, any instance of a map parsed through recursive apply calls will continue to recurse until a primitive value is parsed and returned. An example of this case:

Rule:

{"if":[ 
	{"==":[{"var":"foo"},"bar"]},{"foo":"is_bar","path":"foo_is_bar"},
	{"foo":"not_bar","path":"default_object"}
]}

Data:

{"foo": "bar"}

The expected return value here is the full object {"foo":"is_bar","path":"foo_is_bar"} which is the case in the jsonlogic playground: https://jsonlogic.com/play.html

However, this currently is parsed to a boolean value true

In the playground (https://jsonlogic.com/play.html) and in version < 3.5.1 the following rule

{
      "some": [
        {"var": "A"},
        {"!=": [
          {"var": ".B"},
          {"var": "B"}
        ]}
      ]
}

when applied to

{"A":[{"B":1}], "B":2}

returns true.

However, since this commit 0926afe, the return value is false.

Is it a desired change? If so, how the previous functionality (of comparing the value with the value from external scope) can be achieved.

Have:

func equals(a, b interface{}) bool {
	if isNumber(a) {
		return toNumber(a) == toNumber(b)
	}

	return toString(a) == toString(b)
}

Need:

func equals(a, b interface{}) bool {
	if isNumber(a) {
		return toNumber(a) == toNumber(b)
	}
        if isBool(a) {
                return isTrue(a) == isTrue(b)
         }
	return toString(a) == toString(b)
}

Else:
panic: interface conversion: interface {} is bool, not string

Here is the sample program to reproduce

package main

import (
	"bytes"
	"fmt"
	"strings"
	"github.com/diegoholiveira/jsonlogic"
)

func main() {
	rule := `{"/":[0,10]}`
	logic := strings.NewReader(rule)
	data := strings.NewReader(`{}`)
	var result bytes.Buffer

	jsonlogic.Apply(logic, data, &result)

	fmt.Println(result.String())

}

Rule:
{ "!=": [ { "var": "before" }, null ] }
Data:
{"before": null, "after": "text"}

This gives true, found some workaround for now to fix the problem (using comparing <> operators).

func main() {
	rule := map[string]interface{}{
		"==": []interface{}{
			map[string]interface{}{
				"var": "impact_levels",
			},
			1,
		},
	}

	data := map[string]interface{}{
		"impact_levels": 1,
	}

	output, err := jsonlogic.ApplyInterface(rule, data)
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Println(output.(bool))
}

this returns an error, the reason seems to be that isNumber is checking for reflect.Float64, and therefor the int is assumed to be a string.

Hi,

Reaching a bug when applying the following logic/data :

• logic : {"or": [{"<=": [100, {"var": "ANY_VAR_EXCEPT_temperature"}, 200]}]}

• data : {"temperature": 12}

Here is a playground showing the problem : https://play.golang.org/p/cznGTSvuSgG

Can someone have a look ?

Regards,

Hey @diegoholiveira,

I'm using this library to apply a jsonlogic built from my UI (using https://react-querybuilder.js.org), but for my use case, I need to help users to "debug" if the response is false

To achieve this, my idea is to print to the user, the logic applied, but I want the vars replaced directly. To be clear, instead of

{
  "and":[
    { "==":[{ "var":"VariableA" }, true] },
    { "==":[{ "var":"VariableB" }, true] },
    { ">=":[{ "var":"VariableC" }, 17179869184] },
    { "==":[{ "var":"VariableD" }, "0"] },
    { "<":[{ "var":"VariableE" }, 20] }
  ]
}

I need

{
  "and":[
    { "==":[false, true] },
    { "==":[true, true] },
    { ">=":[34359738368, 17179869184] },
    { "==":[12, "0"] },
    { "<":[14, 20] }
  ]
}

I haven't seen any function that can achieve this (only solveVars and getVar)
There is any way to get this result ?

Kindly

I think it would be very useful if adding custom operator is supported.

Like: http://jsonlogic.com/add_operation.html

Hello,

I am trying to override == and all operator for my implementation. To do so, my code looks like this:

jsonlogic.AddOperator("==", util.EqualsOperator)
jsonlogic.AddOperator("all", util.AllOperator)

And then I have implementation for both the methods above that look like this:

func EqualsOperator(values, data interface{}) interface{} {
//implentation goes here
}

func AllOperator(values, data interface{}) interface{} {
//implentation goes here
}

My filter looks like this:

          {
                "and": [
                    {
                        "==": [
                            {
                                "var": "deploymentt.id"
                            },
                            "test123"
                        ]
                    },
                    {
                        "all": [
                            {
                                "var": "values"
                            },
                            [               
                              "value 1",
                              "value 2"
                            ]
                        ]
                    }
                ]
            }

I am facing a weird issue. When I run my code against this filter and sample data that should match this condition, my breakpoint for EqualsOperator hits and my override of the jsonLogic operator works. But my override of AllOperator does not work, the breakpoint never hits and it used the default jsonLogic implementation.

Can you help?

I used go get to install and here is the error that I got while running a basic example:

cannot use logic (type interface {}) as type io.Reader in argument to jsonlogic.Apply:
interface {} does not implement io.Reader (missing Read method)
[go]
cannot use data (type interface {}) as type io.Reader in argument to jsonlogic.Apply:
interface {} does not implement io.Reader (missing Read method)

In the example here, https://jsonlogic.com/operations#substr, a negative number greater than the string length is no problem. The entire string is simply returned:

{"substr": ["jsonlogic", -10]} // "jsonlogic"

However, In this minimal example, I get an error and a empty output`:

	var result bytes.Buffer
	data := strings.NewReader(`{}`)
	logic := strings.NewReader(`
	{"substr": ["jsonlogic", -10]}`)
	err := jsonlogic.Apply(logic, data, &result)
	if err != nil {
		log.Printf("err: %s", err.Error())	// err: runtime error: slice bounds out of range [-1:]
	}

	log.Printf("got result: %s", result.String()) // got result: 

I believe this is an error... So I'm looking at a fix.

Hi contributors & users,

I am facing a bug with the following data & logic :

x Data :
{} or whatever data without a matching var
x Logic :
{"and":[{"<":[{"var":"foo"},"bar"]}]}
x Evaluation : true

You can play with the bug here : https://play.golang.org/p/1fBwpHNhxKk

What's funny is that if you change the greater for a lower, evaluation becomes falsy. In both case it should be false (as verified on jsonlogic.com playground) since there is no matching var in the data.

Thanks

Hey, not sure if this is best place to post this question, as I don't think it is a problem with the golang jsonlogic as I am noticing the same behavior in go as I do in the play.html page on jsonlogic, but I'm trying to figure out how I can compare array values against data outside of the array

I know that var inside of an array is relative, so { "var": "id" } appears to work, but is there any way I could check that against data outside of the array like the subject.id. If var inside an array is only relative, is the only solution to add a custom operator like absolute_var, if yes, if there any online examples where I could understand how to write an operator like that in golang

Rule: {"some": [{ "var": "attributes.parents" }, {"==": [{ "var": "id" }, { "var": "subject.id" }]}]}

Data: { "subject": { "id": "hugh", }, "attributes": { "parents": [ { "id": "ryan" }, { "id": "hugh" }, ] } }

package main

import (
	"bytes"
	"fmt"
	"strings"

	"github.com/diegoholiveira/jsonlogic/v3"
)

func main() {
	logic := strings.NewReader(`{"<": ["9", 10]}`)
	data := strings.NewReader(`{}`)

	var result bytes.Buffer

	jsonlogic.Apply(logic, data, &result)

	fmt.Println(result.String())
}

expect true
but got false

Using rule: {"notanoperator": [1, 1]}
and data: {}
on the web playground( http://jsonlogic.com/play.html) appropriately yields:Unrecognized operation notanoperator

However using this package results in a successful evaluation with a result of true.

Using module: github.com/diegoholiveira/jsonlogic v2.2.0+incompatible

Hey @diegoholiveira

I'm using JsonLogic in Go backend, with sometimes complex logics (lot of sums, conditional ...)
And in order to help my end users to debug in case of false result, I'm asking if there is a way to output the variable that cause the false output

For example, output just need to be a string with variable name

{
  "and":[
    { "==":[{ "var":"VariableA" }, true] },
    { ">=":[{ "var":"VariableC" }, 17179869184] },
  ]
}

If VariableA = false and VariableC = 17179869184
The jsonlogic.Apply() output can be result, variable, err := jsonlogic.Apply()
With variable = "VariableA" (or maybe an array in case of multiple var, or maybe only the first that cause false result)

Do you think, this kind of behavior can be achieve, or because of the operation of jsonlogic which works with json, this will not be possible?

If yes, if you have some tips, maybe I can achieve this, and make another PR !

reproduce

logic = {"==":[{"var":"test"},true]}
data = {}

stack trace

panic: interface conversion: interface {} is bool, not string [recovered]
	panic: interface conversion: interface {} is bool, not string

goroutine 6 [running]:
testing.tRunner.func1.1(0x54d6e0, 0xc000100420)
	/home/liangliangdai/.asdf/installs/golang/1.14/go/src/testing/testing.go:941 +0x3d0
testing.tRunner.func1(0xc000132120)
	/home/liangliangdai/.asdf/installs/golang/1.14/go/src/testing/testing.go:944 +0x3f9
panic(0x54d6e0, 0xc000100420)
	/home/liangliangdai/.asdf/installs/golang/1.14/go/src/runtime/panic.go:967 +0x15d
github.com/diegoholiveira/jsonlogic.toString(0x5404a0, 0x683ee1, 0x0, 0x0)
	/home/liangliangdai/.asdf/installs/golang/1.16/go/pkg/mod/github.com/diegoholiveira/[email protected]+incompatible/helpers.go:74 +0x108
github.com/diegoholiveira/jsonlogic.equals(0x0, 0x0, 0x5404a0, 0x683ee1, 0xc00000c120)
	/home/liangliangdai/.asdf/installs/golang/1.16/go/pkg/mod/github.com/diegoholiveira/[email protected]+incompatible/comp.go:34 +0xbd
github.com/diegoholiveira/jsonlogic.operation(0xc00001c2e8, 0x2, 0x53ea80, 0xc00000c140, 0x54c500, 0xc0001003c0, 0xc000068530, 0x53a400)
	/home/liangliangdai/.asdf/installs/golang/1.16/go/pkg/mod/github.com/diegoholiveira/[email protected]+incompatible/jsonlogic.go:658 +0xa70
github.com/diegoholiveira/jsonlogic.apply(0x54c500, 0xc000100360, 0x54c500, 0xc0001003c0, 0xc000068500, 0x0)
	/home/liangliangdai/.asdf/installs/golang/1.16/go/pkg/mod/github.com/diegoholiveira/[email protected]+incompatible/jsonlogic.go:708 +0x1b5
github.com/diegoholiveira/jsonlogic.ApplyRaw(0xc000016480, 0x1d, 0x20, 0xc00001c2d8, 0x2, 0x8, 0x685ae0, 0x0, 0x1, 0xc000052748, ...)
	/home/liangliangdai/.asdf/installs/golang/1.16/go/pkg/mod/github.com/diegoholiveira/[email protected]+incompatible/jsonlogic.go:761 +0x23e
study_go2/jsonlogic.TestUsage(0xc000132120)
	/home/liangliangdai/IdeaProjects/study_go2/jsonlogic/jsonlogic_test.go:13 +0xb3
testing.tRunner(0xc000132120, 0x581c90)
	/home/liangliangdai/.asdf/installs/golang/1.14/go/src/testing/testing.go:992 +0xdc
created by testing.(*T).Run
	/home/liangliangdai/.asdf/installs/golang/1.14/go/src/testing/testing.go:1043 +0x357

Process finished with the exit code 1

others

it works when modify true to "true"

but result different with playground, which is correct ?

seems no judgement for bool here

First of all, that's a great lib, thank you all for your hard work on this!

When we try to access an specific condition in an empty array, we get index out of range.
How can we check if the array is not empty before accessing their items?

Quick playground example

logic := strings.NewReader(`{"if":[ false, {"var":"values.0.categories"}, "else" ]}`)
data := strings.NewReader(`{ "values": [] }`)

var result bytes.Buffer
if err := jsonlogic.Apply(logic, data, &result); err != nil {
    fmt.Printf("failed, %v", err)
}

fmt.Println(result.String())

In the example above, even forcing the false in the if condition, it's still evaluating the true part, causing the index out of range.
Shouldn't return the "else" value , even returning the error?
This is what the JSON Logic playground returns:

Is there any other way to get the value of a property from an array's item (like categories from the first position in my example)?

Thank you

Hi
I am trying to run the following kind of rule
rule
{ "all": [ { "var": "" }, { "in": [ {"var": "P1"} , ["A","B"]] } ] }
for the following JSON data:
[ { "P1": "A", "P2": "a" }, { "P1": "B", "P2": "b" } ]

But the Apply function call gives me false which is incorrect evaluation.

"Limitations" part has no comments in code that shows where exactly improper values are used.

Using the full {"var": [...]} syntax instead of the syntax sugar {"var": "..."} causes an error when present in a filter body. As an example, the following rule (adapted from the test suite) will fail:

	{
		"filter": [
			{"var": ["people"]},
			{"==": [
				{"var": [".age"]},
				{"min": {"map": [
					{"var": ["people"]},
					{"var": [".age"]}
				]}}
			]}
		]
	}

with the data:

	{
		"people": [
			{"age":18, "name":"John"},
			{"age":20, "name":"Luke"},
			{"age":18, "name":"Mark"}
		]
	}

I believe the cause is this line: https://github.com/diegoholiveira/jsonlogic/blob/master/vars.go#L15

Sample code to reproduce

import (
	"bytes"
	"fmt"
	"strings"

	"github.com/diegoholiveira/jsonlogic"
)

func main() {

	logic := strings.NewReader(`{"and":[{">":[{"*":[{"/":[{"var":"tradeItems.43443.quantity.REJECTED"},{"var":"tradeItems.43443.quantity.RECEIVED"}]},100]},0.1]}]}`)
	data := strings.NewReader(`{"tradeItems":{"43443":{"lineItemNo":1,"itemName":"Item16","SKUCode":"43443","HSNCode":"45455","quantity":{"ACCEPTED":4500,"APPROVED":0,"DESTRUCTED":0,"INTRANSIT":4500,"INVOICED":4500,"INVOICED_REMAINING":0,"INVOICE_APPROVED":0,"INVOICE_PAID":0,"INVOICE_REJECTED":0,"ORDERED":4500,"QC":4500,"QC_REMAINING":0,"READY_TO_SHIP":4500,"READY_TO_SHIP_REMAINING":0,"RECEIVED":4500,"REJECTED":0,"REQUESTED":0,"REQUESTED_REMAINING":0,"SCRAPPED":0},"supplier":{"orgId":"DESU1","orgName":"Supplier Org1","emailId":"","vendorCode":"","address":"Juhu Road","departmentId":""},"receiver":{"orgId":"DEOW1","orgName":"Buyer","emailId":"","vendorCode":"","address":"T-68-1","departmentId":""},"deliverBy":"2020-04-30T18:29:59Z","deliverByUnixTs":1588271399,"pricePerUnit":30,"qualityMeasure":"","reasonForRejection":"","taxApplicable":{"CGST":{"id":"","taxName":"CGST","taxRate":8,"taxAmount":10800,"isApplicable":true},"IGST":{"id":"","taxName":"","taxRate":0,"taxAmount":0,"isApplicable":false},"SGST":{"id":"","taxName":"SGST","taxRate":8,"taxAmount":10800,"isApplicable":true}},"items":[],"shopOrder":"","totalAmount":0}}}`)
	var result bytes.Buffer

	err := jsonlogic.Apply(logic, data, &result)

	fmt.Println(result.String())
	fmt.Println(err)
}


error :
 panic: interface conversion: interface {} is map[string]interface {}, not []interface {}

goroutine 1 [running]:
github.com/diegoholiveira/jsonlogic.getVar(0x154500, 0x40c178, 0x154e60, 0x43e3e0, 0x0, 0x154e60)
	/tmp/gopath790557694/pkg/mod/github.com/diegoholiveira/[email protected]+incompatible/vars.go:89 +0x740
github.com/diegoholiveira/jsonlogic.operation(0x40e053, 0x3, 0x154500, 0x40c178, 0x154e60, 0x43e3e0, 0x132500, 0x1c8f)
	/tmp/gopath790557694/pkg/mod/github.com/diegoholiveira/[email protected]+incompatible/jsonlogic.go:540 +0x1120
github.com/diegoholiveira/jsonlogic.apply(0x154e60, 0x43e3a0, 0x154e60, 0x43e3e0, 0x277801, 0x15d240)
	/tmp/gopath790557694/pkg/mod/github.com/diegoholiveira/[email protected]+incompatible/jsonlogic.go:708 +0x1e0
github.com/diegoholiveira/jsonlogic.parseValues(0x14d940, 0x40a0f0, 0x154e60, 0x43e3e0, 0x0, 0x1c00)
	/tmp/gopath790557694/pkg/mod/github.com/diegoholiveira/[email protected]+incompatible/jsonlogic.go:674 +0x260
github.com/diegoholiveira/jsonlogic.apply(0x154e60, 0x43e380, 0x154e60, 0x43e3e0, 0x277801, 0x16e9a7)
	/tmp/gopath790557694/pkg/mod/github.com/diegoholiveira/[email protected]+incompatible/jsonlogic.go:708 +0x1a0
github.com/diegoholiveira/jsonlogic.parseValues(0x14d940, 0x40a110, 0x154e60, 0x43e3e0, 0xfefc9a08, 0x0)
	/tmp/gopath790557694/pkg/mod/github.com/diegoholiveira/[email protected]+incompatible/jsonlogic.go:674 +0x260
github.com/diegoholiveira/jsonlogic.apply(0x154e60, 0x43e360, 0x154e60, 0x43e3e0, 0x277801, 0x8)
	/tmp/gopath790557694/pkg/mod/github.com/diegoholiveira/[email protected]+incompatible/jsonlogic.go:708 +0x1a0
github.com/diegoholiveira/jsonlogic.parseValues(0x14d940, 0x40a130, 0x154e60, 0x43e3e0, 0x40e0a0, 0x1010000)
	/tmp/gopath790557694/pkg/mod/github.com/diegoholiveira/[email protected]+incompatible/jsonlogic.go:674 +0x260
github.com/diegoholiveira/jsonlogic.apply(0x154e60, 0x43e340, 0x154e60, 0x43e3e0, 0x277801, 0x1c8f)
	/tmp/gopath790557694/pkg/mod/github.com/diegoholiveira/[email protected]+incompatible/jsonlogic.go:708 +0x1a0
github.com/diegoholiveira/jsonlogic.parseValues(0x14d940, 0x40a140, 0x154e60, 0x43e3e0, 0x16, 0x1c8f)
	/tmp/gopath790557694/pkg/mod/github.com/diegoholiveira/[email protected]+incompatible/jsonlogic.go:674 +0x260
github.com/diegoholiveira/jsonlogic.apply(0x154e60, 0x43e320, 0x154e60, 0x43e3e0, 0x1, 0x0)
	/tmp/gopath790557694/pkg/mod/github.com/diegoholiveira/[email protected]+incompatible/jsonlogic.go:708 +0x1a0
github.com/diegoholiveira/jsonlogic.Apply(0x1c0300, 0x43e2c0, 0x1c0300, 0x43e2e0, 0x1c0140, 0x43e300, 0x1, 0x4)
	/tmp/gopath790557694/pkg/mod/github.com/diegoholiveira/[email protected]+incompatible/jsonlogic.go:736 +0x220
main.main()
	/tmp/sandbox395415131/prog.go:17 +0x140

As pointed out in #35 your go.mod module name needs /v2
This looks to be corrected for V3 but it is very strange that your go.mod for V3 references your own module as github.com/diegoholiveira/jsonlogic v2.3.1+incompatible

https://github.com/diegoholiveira/jsonlogic/blob/v3.0.0/go.mod#L6

We are using Go 1.16 and 1.17 which is not allowing us to use any thing higher than github.com/diegoholiveira/jsonlogic v1.0.1-0.20200220175622-ab7989be08b9 in Edgex Foundry here:

https://github.com/edgexfoundry/app-functions-sdk-go/blob/main/go.mod#L7

Error Operation Equals with nulls, which both parameters are null gives me a false response logic := strings.NewReader('{"==": [null, null]}'); but from the operations page operations I get a true response

Checking, there is a condition in the function Equals, indicating that if any is nil, it returns false; which I don't see is the right solution