Expr Playground implementation

[texonidas]

Hi, I was wondering how the playground has been implemented to allow for strict compiling, specifically how you are generating the types from the JSON? We are looking to emulate this to verify rules produced by business users that are consumed by our rules engine, potentially reusable in a CI pipeline.

[antonmedv]

Expr Playground uses a new types package in Expr: https://pkg.go.dev/github.com/expr-lang/expr@v1.17.7/types

With this package you can define types with more strict guidance:

strictMap := types.Map{
    "foo": types.Int,
    "bar": types.TypeOf(myStruct).
}

And if you want to define a map which also contains additional (or default keys):

types.Map{
    "foo": types.Int,
    "bar": types.TypeOf(myStruct).
    types.Extra: types.Any,
}

I will add a documentation about new types packages.

[texonidas]

In the playground you seem to have compile checking on arbitrary JSON being defined in env section. How is that specifically being implemented?

[antonmedv]

//go:build js && wasm

package main

import (
	"encoding/json"
	"math"
	"time"

	"github.com/expr-lang/expr/types"
)

func parseEnv(envString string) (map[string]any, types.Type, error) {
	var env map[string]any
	err := json.Unmarshal([]byte(envString), &env)
	if err != nil {
		return nil, nil, err
	}
	return replace(env).(map[string]any), withTypes(env), nil
}

func replace(env any) any {
	switch it := env.(type) {
	case map[string]any:
		m := map[string]any{}
		for k, v := range it {
			m[k] = replace(v)
		}
		return m
	case []any:
		a := []any{}
		for _, v := range it {
			a = append(a, replace(v))
		}
		return a
	case string:
		t, ok := parseDate(it)
		if ok {
			return t
		}
		return it
	case float64:
		if canBeInt(it) {
			return int(it)
		}
		return it
	default:
		return it
	}
}

func withTypes(it any) types.Type {
	switch it := it.(type) {

	case map[string]any:
		t := types.Map{}
		for k, v := range it {
			t[k] = withTypes(v)
		}
		return t

	case []any:
		if len(it) == 0 {
			return types.Array(types.Nil)
		}
		first := withTypes(it[0])
		allElementsAreSame := true
		allElementsAreMaps := true
		allKeys := map[string]types.Type{}
		for i := 0; i < len(it); i++ {
			element := withTypes(it[i])
			if !element.Equal(first) {
				allElementsAreSame = false
			}
			if m, ok := element.(types.Map); ok {
				for k, v := range m {
					allKeys[k] = v
				}
				continue
			}
			allElementsAreMaps = false
		}
		if allElementsAreSame {
			return types.Array(first)
		}
		if allElementsAreMaps {
			m := types.Map{}
			for k, v := range allKeys {
				m[k] = v
			}
			return types.Array(m)
		}
		return types.Array(types.Any)

	case string:
		t, ok := parseDate(it)
		if ok {
			return types.TypeOf(t)
		}
		return types.String

	case float64:
		if canBeInt(it) {
			return types.Int
		}
		return types.Float

	default:
		return types.TypeOf(it)
	}
}

// parseDate parses a string into a time.Time,
// s must be in one of the following formats:
// - 2006-01-02 15:04:05
// - RFC3339
// - RFC822,
// - RFC850,
// - RFC1123,
func parseDate(s string) (time.Time, bool) {
	t, err := time.Parse("2006-01-02 15:04:05", s)
	if err == nil {
		return t, true
	}
	t, err = time.Parse(time.RFC3339, s)
	if err == nil {
		return t, true
	}
	t, err = time.Parse(time.RFC822, s)
	if err == nil {
		return t, true
	}
	t, err = time.Parse(time.RFC850, s)
	if err == nil {
		return t, true
	}
	t, err = time.Parse(time.RFC1123, s)
	if err == nil {
		return t, true
	}
	return time.Time{}, false
}

func canBeInt(f float64) bool {
	if f < math.MinInt64 || f > math.MaxInt64 {
		return false
	}
	return f == float64(int64(f))
}