jsonlogic

README

Go JSON Logic

Implementation of JSON Logic in Go Lang.

What's JSON Logic?

JSON Logic is a DSL to write logic decisions in JSON. It's has a great specification and is very simple to learn. The official website has a great documentation with examples.

How to use it

The use of this library is very straightforward. Here's a simple example:

package main

import (
	"bytes"
	"fmt"
	"strings"

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

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

	var result bytes.Buffer

	jsonlogic.Apply(logic, data, &result)

	fmt.Println(result.String())
}

This will output true in your console.

Here's another example, but this time using variables passed in the data parameter:

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"strings"

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

type (
	User struct {
		Name     string `json:"name"`
		Age      int    `json:"age"`
		Location string `json:"location"`
	}

	Users []User
)

func main() {
	logic := strings.NewReader(`{
        "filter": [
            {"var": "users"},
            {">=": [
                {"var": ".age"},
                18
            ]}
        ]
    }`)

	data := strings.NewReader(`{
        "users": [
            {"name": "Diego", "age": 33, "location": "Florianópolis"},
            {"name": "Jack", "age": 12, "location": "London"},
            {"name": "Pedro", "age": 19, "location": "Lisbon"},
            {"name": "Leopoldina", "age": 30, "location": "Rio de Janeiro"}
        ]
    }`)

	var result bytes.Buffer

	err := jsonlogic.Apply(logic, data, &result)
	if err != nil {
		fmt.Println(err.Error())

		return
	}

	var users Users

	decoder := json.NewDecoder(&result)
	decoder.Decode(&users)

	for _, user := range users {
		fmt.Printf("    - %s\n", user.Name)
	}
}

If you have a function you want to expose as a JSON Logic operation, you can use:

package main

import (
	"bytes"
	"fmt"
	"strings"

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

func main() {
	// add a new operator "strlen" for get string length
	jsonlogic.AddOperator("strlen", func(values, data interface{}) interface{} {
		v, ok := values.(string)
		if ok {
			return len(v)
		}
		return 0
	})

	logic := strings.NewReader(`{ "strlen": { "var": "foo" } }`)
	data := strings.NewReader(`{"foo": "bar"}`)

	var result bytes.Buffer

	jsonlogic.Apply(logic, data, &result)

	fmt.Println(result.String()) // the string length of "bar" is 3
}

License

This project is licensed under the MIT License - see the LICENSE file for details

Documentation

Index

• func AddOperator(key string, cb func(values, data interface{}) (result interface{}))
• func Apply(rule, data io.Reader, result io.Writer) error
• func ApplyInterface(rule, data interface{}) (output interface{}, err error)
• func ApplyRaw(rule, data json.RawMessage) (json.RawMessage, error)
• func GetJsonLogicWithSolvedVars(rule, data json.RawMessage) ([]byte, error)
• func IsValid(rule io.Reader) bool
• func ValidateJsonLogic(rules interface{}) bool
• type ErrInvalidOperator
  • func (e ErrInvalidOperator) Error() string
• type ErrReduceDataType
  • func (e ErrReduceDataType) Error() string

Functions

func AddOperator

func AddOperator(key string, cb func(values, data interface{}) (result interface{}))

AddOperator allows for custom operators to be used

func Apply

func Apply(rule, data io.Reader, result io.Writer) error

Apply read the rule and it's data from io.Reader, executes it and write back a JSON into an io.Writer result

func ApplyInterface

func ApplyInterface(rule, data interface{}) (output interface{}, err error)

func ApplyRaw

func ApplyRaw(rule, data json.RawMessage) (json.RawMessage, error)

func GetJsonLogicWithSolvedVars

func GetJsonLogicWithSolvedVars(rule, data json.RawMessage) ([]byte, error)

func IsValid

func IsValid(rule io.Reader) bool

IsValid reads a JSON Logic rule from io.Reader and validates it

func ValidateJsonLogic

func ValidateJsonLogic(rules interface{}) bool

Types

type ErrInvalidOperator

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

func (ErrInvalidOperator) Error

func (e ErrInvalidOperator) Error() string

type ErrReduceDataType

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

func (ErrReduceDataType) Error

func (e ErrReduceDataType) Error() string