Expose the CEL JSON types to assist with conversion to native values (#1261)

Author: TristonianJones

cel/cel_test.go

@@ -17,6 +17,7 @@ package cel
 import (
 	"bytes"
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"os"
@@ -239,6 +240,43 @@ func TestAbbrevsDisambiguation(t *testing.T) {
 	}
 }
 
+func TestConvertToNativeJSONStructure(t *testing.T) {
+	env, err := NewEnv()
+	if err != nil {
+		t.Fatalf("NewEnv() failed: %v", err)
+	}
+	ast, issues := env.Compile(`{
+		"parts": [{"kind": "text"}]
+	}`)
+	if issues != nil && issues.Err() != nil {
+		t.Fatal(issues.Err())
+	}
+
+	prg, err := env.Program(ast)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	result, _, err := prg.Eval(map[string]any{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	native, err := result.ConvertToNative(types.JSONValueType)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	jsonBytes, err := json.Marshal(native)
+	if err != nil {
+		t.Fatalf("json.Marshal failed: %v", err)
+	}
+	want := `{"parts":[{"kind":"text"}]}`
+	if string(jsonBytes) != want {
+		t.Errorf("json.Marshal() failed, got : %s, wanted ", jsonBytes)
+	}
+}
+
 func TestCustomEnvError(t *testing.T) {
 	env, err := NewCustomEnv(StdLib(), StdLib())
 	if err != nil {

common/types/bool.go

@@ -69,7 +69,7 @@ func (b Bool) ConvertToNative(typeDesc reflect.Type) (any, error) {
 		case boolWrapperType:
 			// Convert the bool to a wrapperspb.BoolValue.
 			return wrapperspb.Bool(bool(b)), nil
-		case jsonValueType:
+		case JSONValueType:
 			// Return the bool as a new structpb.Value.
 			return structpb.NewBoolValue(bool(b)), nil
 		default:

common/types/bool_test.go

@@ -76,7 +76,7 @@ func TestBoolConvertToNative_Error(t *testing.T) {
 }
 
 func TestBoolConvertToNative_Json(t *testing.T) {
-	val, err := True.ConvertToNative(jsonValueType)
+	val, err := True.ConvertToNative(JSONValueType)
 	pbVal := &structpb.Value{Kind: &structpb.Value_BoolValue{BoolValue: true}}
 	if err != nil {
 		t.Error(err)

common/types/bytes.go

@@ -79,7 +79,7 @@ func (b Bytes) ConvertToNative(typeDesc reflect.Type) (any, error) {
 		case byteWrapperType:
 			// Convert the bytes to a wrapperspb.BytesValue.
 			return wrapperspb.Bytes([]byte(b)), nil
-		case jsonValueType:
+		case JSONValueType:
 			// CEL follows the proto3 to JSON conversion by encoding bytes to a string via base64.
 			// The encoding below matches the golang 'encoding/json' behavior during marshaling,
 			// which uses base64.StdEncoding.

common/types/bytes_test.go

@@ -97,7 +97,7 @@ func TestBytesConvertToNative_Error(t *testing.T) {
 }
 
 func TestBytesConvertToNative_Json(t *testing.T) {
-	val, err := Bytes("123").ConvertToNative(jsonValueType)
+	val, err := Bytes("123").ConvertToNative(JSONValueType)
 	if err != nil {
 		t.Error(err)
 	}

common/types/double.go

@@ -89,7 +89,7 @@ func (d Double) ConvertToNative(typeDesc reflect.Type) (any, error) {
 		case floatWrapperType:
 			// Convert to a wrapperspb.FloatValue (with truncation).
 			return wrapperspb.Float(float32(d)), nil
-		case jsonValueType:
+		case JSONValueType:
 			// Note, there are special cases for proto3 to json conversion that
 			// expect the floating point value to be converted to a NaN,
 			// Infinity, or -Infinity string values, but the jsonpb string

common/types/double_test.go

@@ -171,15 +171,15 @@ func TestDoubleConvertToNative_Float64(t *testing.T) {
 }
 
 func TestDoubleConvertToNative_Json(t *testing.T) {
-	val, err := Double(-1.4).ConvertToNative(jsonValueType)
+	val, err := Double(-1.4).ConvertToNative(JSONValueType)
 	pbVal := structpb.NewNumberValue(-1.4)
 	if err != nil {
 		t.Error(err)
 	} else if !proto.Equal(val.(proto.Message), pbVal) {
 		t.Errorf("Got '%v', expected -1.4", val)
 	}
 
-	val, err = Double(math.NaN()).ConvertToNative(jsonValueType)
+	val, err = Double(math.NaN()).ConvertToNative(JSONValueType)
 	if err != nil {
 		t.Error(err)
 	} else {
@@ -189,14 +189,14 @@ func TestDoubleConvertToNative_Json(t *testing.T) {
 		}
 	}
 
-	val, err = Double(math.Inf(-1)).ConvertToNative(jsonValueType)
+	val, err = Double(math.Inf(-1)).ConvertToNative(JSONValueType)
 	pbVal = structpb.NewNumberValue(math.Inf(-1))
 	if err != nil {
 		t.Error(err)
 	} else if !proto.Equal(val.(proto.Message), pbVal) {
 		t.Errorf("Got '%v', expected -Infinity", val)
 	}
-	val, err = Double(math.Inf(0)).ConvertToNative(jsonValueType)
+	val, err = Double(math.Inf(0)).ConvertToNative(JSONValueType)
 	pbVal = structpb.NewNumberValue(math.Inf(0))
 	if err != nil {
 		t.Error(err)

common/types/duration.go

@@ -106,7 +106,7 @@ func (d Duration) ConvertToNative(typeDesc reflect.Type) (any, error) {
 	case durationValueType:
 		// Unwrap the CEL value to its underlying proto value.
 		return dpb.New(d.Duration), nil
-	case jsonValueType:
+	case JSONValueType:
 		// CEL follows the proto3 to JSON conversion.
 		// Note, using jsonpb would wrap the result in extra double quotes.
 		v := d.ConvertToType(StringType)

common/types/duration_test.go

@@ -166,7 +166,7 @@ func TestDurationConvertToNative_Any(t *testing.T) {
 }
 
 func TestDurationConvertToNative_Error(t *testing.T) {
-	val, err := Duration{Duration: duration(7506, 1000)}.ConvertToNative(jsonValueType)
+	val, err := Duration{Duration: duration(7506, 1000)}.ConvertToNative(JSONValueType)
 	if err != nil {
 		t.Errorf("Got error: '%v', expected value", err)
 	}
@@ -178,7 +178,7 @@ func TestDurationConvertToNative_Error(t *testing.T) {
 }
 
 func TestDurationConvertToNative_Json(t *testing.T) {
-	val, err := Duration{Duration: duration(7506, 1000)}.ConvertToNative(jsonValueType)
+	val, err := Duration{Duration: duration(7506, 1000)}.ConvertToNative(JSONValueType)
 	if err != nil {
 		t.Error(err)
 	}

common/types/int.go

@@ -120,7 +120,7 @@ func (i Int) ConvertToNative(typeDesc reflect.Type) (any, error) {
 		case int64WrapperType:
 			// Convert the value to a wrapperspb.Int64Value.
 			return wrapperspb.Int64(int64(i)), nil
-		case jsonValueType:
+		case JSONValueType:
 			// The proto-to-JSON conversion rules would convert all 64-bit integer values to JSON
 			// decimal strings. Because CEL ints might come from the automatic widening of 32-bit
 			// values in protos, the JSON type is chosen dynamically based on the value.