Support objects in expressions

src/Altinn.App.Core/Internal/Expressions/ExpressionEvaluator.cs

@@ -18,7 +18,7 @@
     /// <summary>
     /// Shortcut for evaluating a boolean expression on a given property on a <see cref="Models.Layout.Components.Base.BaseComponent" />
     /// </summary>
     [Obsolete("Use ComponentContext.IsHidden or ComponentContext.EvaluateExpression instead")]
     public static async Task<bool> EvaluateBooleanExpression(
         LayoutEvaluatorState state,
         ComponentContext context,
@@ -147,6 +147,7 @@
             ExpressionFunction.multiply => Multiply(args),
             ExpressionFunction.divide => Divide(args),
             ExpressionFunction.list => List(args),
+            ExpressionFunction.@object => Object(args),
             ExpressionFunction.INVALID => throw new ExpressionEvaluatorTypeErrorException(
                 $"Function {expr.Args.FirstOrDefault()} not implemented in backend {expr}"
             ),
@@ -763,7 +764,7 @@
         }
 
         var all = true;
         foreach (var arg in args)
         {
             // the LINQ All() method would short-circuit and not evaluate all args, so we do it manually to ensure exceptions are thrown correctly
             if (!PrepareBooleanArg(arg))
@@ -805,7 +806,7 @@
         }
 
         bool any = false;
         foreach (var arg in args)
         {
             // the LINQ Any() method would short-circuit and not evaluate all args, so we do it manually to ensure exceptions are thrown correctly
             if (PrepareBooleanArg(arg))
@@ -1018,6 +1019,11 @@
         return new JsonArray(args.Select(a => JsonSerializer.SerializeToNode(a)).ToArray());
     }
 
+    private static ExpressionValue Object(ExpressionValue[] args)
+    {
+        return ObjectFunctionEvaluator.Evaluate(args);
+    }
+
     /// <summary>
     /// Performs arithmetic operation using decimal precision to avoid floating point precision issues.
     /// Converts doubles to decimal, performs the operation, and converts back to double.

src/Altinn.App.Core/Internal/Expressions/ExpressionValue.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using System.Numerics;
 using System.Text.Encodings.Web;
 using System.Text.Json;
 using System.Text.Json.Nodes;
@@ -19,7 +20,7 @@
     // double is a value type where nullable takes extra space, and we only read it when it should be set
     private readonly double _numberValue = 0;
 
-    // private readonly Dictionary<string, ExpressionValue>? _objectValue = null;
+    private readonly JsonObject? _objectValue = null;
     private readonly JsonArray? _arrayValue = null;
 
     /// <summary>
@@ -28,7 +29,7 @@
     public ExpressionValue()
         : this(JsonValueKind.Null) { }
 
     private ExpressionValue(JsonValueKind valueKind)
     {
         ValueKind = valueKind;
     }
@@ -84,11 +85,14 @@
         _stringValue = value;
     }
 
-    // private ExpressionValue(Dictionary<string, ExpressionValue>? value)
-    // {
-    //     _valueKind = value is null ? JsonValueKind.Null : JsonValueKind.Object;
-    //     _objectValue = value;
-    // }
+    /// <summary>
+    /// Constructor for object value
+    /// </summary>
+    public ExpressionValue(JsonObject value)
+    {
+        ValueKind = JsonValueKind.Object;
+        _objectValue = value;
+    }
 
     /// <summary>Constructor for array value</summary>
     public ExpressionValue(JsonArray value)
@@ -112,10 +116,10 @@
     /// </summary>
     public static implicit operator ExpressionValue(string? value) => new(value);
 
-    // /// <summary>
-    // /// Convert a Dictionary to ExpressionValue
-    // /// </summary>
-    // public static implicit operator ExpressionValue(Dictionary<string, ExpressionValue>? value) => new(value);
+    /// <summary>
+    /// Convert a Dictionary to ExpressionValue
+    /// </summary>
+    public static implicit operator ExpressionValue(JsonObject value) => new(value);
 
     /// <summary>
     /// Convert an array to ExpressionValue
@@ -174,17 +178,20 @@
                     '"'
                 ) // Trim quotes to match the string representation
             ,
-            JsonArray jsonArrayValue => jsonArrayValue,
-            _ => ToJsonArrayOrNull(value),
+            BigInteger => Null,
+            JsonObject jsonObject => jsonObject,
+            JsonArray jsonArray => jsonArray,
+            _ => ToJsonNodeOrNull(value),
         };
     }
 
-    private static ExpressionValue ToJsonArrayOrNull(object? value)
+    private static ExpressionValue ToJsonNodeOrNull(object? value)
     {
         var node = JsonSerializer.SerializeToNode(value);
         return node switch
         {
             JsonArray jsonArray => jsonArray,
+            JsonObject jsonObject => jsonObject,
             _ => Null,
         };
     }
@@ -202,7 +209,7 @@
             JsonValueKind.False => false,
             JsonValueKind.String => String,
             JsonValueKind.Number => Number,
-            // JsonValueKind.Object => Object,
+            JsonValueKind.Object => Object,
             JsonValueKind.Array => Array,
             _ => throw new InvalidOperationException("Invalid value kind"),
         };
@@ -228,7 +235,7 @@
     /// <summary>
     /// Get the value as a string (or throw if it isn't a string ValueKind)
     /// </summary>
     public string String =>
         ValueKind switch
         {
             JsonValueKind.String => _stringValue ?? throw new UnreachableException("Not a string"),
@@ -249,14 +256,19 @@
             ),
         };
 
-    // public Dictionary<string, ExpressionValue> Object =>
-    //     _valueKind switch
-    //     {
-    //         JsonValueKind.Object => _objectValue ?? throw new UnreachableException($"{this} is not an object"),
-    //         _ => throw new InvalidCastException(
-    //            $"The .Object property can't be used on an expression value that represent a {_valueKind}"
-    //        ),
-    //     };
+#pragma warning disable CA1720
+    /// <summary>
+    /// Get the value as an object (or throw if it isn't an object ValueKind)
+    /// </summary>
+    public JsonObject Object =>
+        ValueKind switch
+        {
+            JsonValueKind.Object => _objectValue ?? throw new UnreachableException($"{this} is not an object"),
+            _ => throw new InvalidCastException(
+                $"The .Object property can't be used on an expression value that represent a {ValueKind}"
+            ),
+        };
+#pragma warning restore CA1720
 
     /// <summary>Get the value as an array (or throw if it isn't an array ValueKind)</summary>
     public JsonArray Array =>
@@ -277,12 +289,12 @@
             JsonValueKind.Null => "null",
             JsonValueKind.Undefined => "undefined",
             JsonValueKind.True => "true",
             JsonValueKind.False => "false",
             JsonValueKind.String => JsonSerializer.Serialize(String, _unsafeSerializerOptionsForSerializingDates),
             JsonValueKind.Number => Number.ToString(CultureInfo.InvariantCulture),
-            // JsonValueKind.Object => JsonSerializer.Serialize(Object),
-            // JsonValueKind.Array => JsonSerializer.Serialize(Array),
+            JsonValueKind.Object => JsonSerializer.Serialize(Object),
+            JsonValueKind.Array => JsonSerializer.Serialize(Array),
             _ => throw new InvalidOperationException($"Invalid value kind {ValueKind}"),
         };
 
     /// <summary>
@@ -302,7 +314,7 @@
             JsonValueKind.False => "false",
             JsonValueKind.String => String,
             JsonValueKind.Number => Number.ToString(CultureInfo.InvariantCulture),
-            // JsonValueKind.Object => JsonSerializer.Serialize(Object),
+            JsonValueKind.Object => JsonSerializer.Serialize(Object),
             JsonValueKind.Array => JsonSerializer.Serialize(Array),
             _ => throw new InvalidOperationException($"Invalid value kind {ValueKind}"),
         };
@@ -340,7 +352,7 @@
     {
         throw new NotImplementedException("Equals is not used for ExpressionValue");
         // First compare value kinds
         // if (_valueKind != other._valueKind)
         //     return false;
 
         // // Then compare actual values based on the kind
@@ -369,7 +381,7 @@
     {
         throw new NotImplementedException("GetHashCode is not implemented for ExpressionValue");
         // return ValueKind switch
         // {
         //     JsonValueKind.Null => 0,
         //     JsonValueKind.True => 1,
         //     JsonValueKind.False => 0,
@@ -486,7 +498,7 @@
     /// <param name="result">The result (null or default if unsuccessful), but note that null might also be a valid result</param>
     /// <param name="type">The type to convert to</param>
     /// <returns>Whether the conversion was successful</returns>
     public bool TryDeserialize(Type type, out object? result)
     {
         // Value types can be Nullable<T>, so assign underlyingType accordingly
         Type underlyingType;
@@ -603,7 +615,7 @@
 
     private static bool IsSupportedNumericType(Type type)
     {
         // TODO: consider supporting enums as numeric types as well, but currently we
         // don't use C# enums in datamodels, so it isn't very urgent.
         return type == typeof(double)
             || type == typeof(int)
@@ -634,7 +646,7 @@
             JsonTokenType.String => reader.GetString(),
             JsonTokenType.Number => reader.GetDouble(),
             JsonTokenType.Null => ExpressionValue.Null,
-            // JsonTokenType.StartObject => ReadObject(ref reader),
+            JsonTokenType.StartObject => ReadObject(ref reader, options),
             JsonTokenType.StartArray => ReadArray(ref reader, options),
             _ => throw new JsonException(),
         };
@@ -652,10 +664,17 @@
         return new ExpressionValue(values);
     }
 
-    // private ExpressionValue ReadObject(ref Utf8JsonReader reader)
-    // {
-    //     throw new NotImplementedException();
-    // }
+    private static ExpressionValue ReadObject(ref Utf8JsonReader reader, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.StartObject)
+        {
+            throw new JsonException("Expected StartObject token.");
+        }
+        var value =
+            JsonSerializer.Deserialize<JsonObject>(ref reader, options)
+            ?? throw new JsonException("Expected JSON object value.");
+        return new ExpressionValue(value);
+    }
 
     /// <inheritdoc />
     public override void Write(Utf8JsonWriter writer, ExpressionValue value, JsonSerializerOptions options)
@@ -678,9 +697,9 @@
             case JsonValueKind.Number:
                 writer.WriteNumberValue(value.Number);
                 break;
-            // case JsonValueKind.Object:
-            //     JsonSerializer.Serialize(writer, value.Object, options);
-            //     break;
+            case JsonValueKind.Object:
+                JsonSerializer.Serialize(writer, value.Object, options);
+                break;
             case JsonValueKind.Array:
                 JsonSerializer.Serialize(writer, value.Array, options);
                 break;

src/Altinn.App.Core/Internal/Expressions/ObjectFunctionEvaluator.cs

@@ -0,0 +1,70 @@
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using Altinn.App.Core.Models.Expressions;
+
+namespace Altinn.App.Core.Internal.Expressions;
+
+internal static class ObjectFunctionEvaluator
+{
+    public static JsonObject Evaluate(ExpressionValue[] args)
+    {
+        AssertEvenNumberOfArguments(args);
+        string[] keys = ExtractKeys(args);
+        AssertKeysAreUnique(keys, args);
+        JsonNode?[] values = ExtractValues(args);
+        Dictionary<string, JsonNode?> keyValuePairs = DictionaryFromKeysAndValues(keys, values);
+        return new JsonObject(keyValuePairs);
+    }
+
+    private static void AssertEvenNumberOfArguments(ExpressionValue[] args)
+    {
+        if (args.Length % 2 == 1)
+        {
+            throw new ExpressionEvaluatorTypeErrorException(
+                "The object function must have an even number of arguments.",
+                ExpressionFunction.@object,
+                args
+            );
+        }
+    }
+
+    private static string[] ExtractKeys(ExpressionValue[] args)
+    {
+        try
+        {
+            return ExtractEvenIndexedArguments(args).Select(v => v.String).ToArray();
+        }
+        catch (InvalidCastException)
+        {
+            throw new ExpressionEvaluatorTypeErrorException(
+                "Object keys must be strings.",
+                ExpressionFunction.@object,
+                args
+            );
+        }
+    }
+
+    private static ExpressionValue[] ExtractEvenIndexedArguments(ExpressionValue[] args) =>
+        args.Where((_, index) => index % 2 == 0).ToArray();
+
+    private static void AssertKeysAreUnique(string[] keys, ExpressionValue[] args)
+    {
+        if (keys.Length != keys.Distinct().Count())
+        {
+            throw new ExpressionEvaluatorTypeErrorException(
+                "Object keys must be unique.",
+                ExpressionFunction.@object,
+                args
+            );
+        }
+    }
+
+    private static JsonNode?[] ExtractValues(ExpressionValue[] args) =>
+        ExtractOddIndexedArguments(args).Select(v => JsonSerializer.SerializeToNode(v)).ToArray();
+
+    private static ExpressionValue[] ExtractOddIndexedArguments(ExpressionValue[] args) =>
+        args.Where((_, index) => index % 2 == 1).ToArray();
+
+    private static Dictionary<string, JsonNode?> DictionaryFromKeysAndValues(string[] keys, JsonNode?[] values) =>
+        keys.Zip(values, (k, v) => new { k, v }).ToDictionary(x => x.k, x => x.v);
+}

src/Altinn.App.Core/Models/Expressions/ExpressionFunction.cs

@@ -228,4 +228,11 @@ public enum ExpressionFunction
 
     /// <summary>Create a list from the arguments.</summary>
     list,
+
+    /// <summary>
+    /// Create a dictionary from the arguments, which must be alternating keys and values.
+    /// </summary>
+#pragma warning disable CA1720
+    @object,
+#pragma warning restore CA1720
 }

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/TestFunctions.cs

@@ -232,6 +232,11 @@ public async Task Divide_Theory(string testName, ExpressionTestCaseRoot.TestCase
     public async Task List_Theory(string testName, ExpressionTestCaseRoot.TestCaseItem testCaseItem) =>
         await RunTestCase(testName, new ExpressionTestCaseRoot(testCaseItem));
 
+    [Theory]
+    [SharedTestCases("object")]
+    public async Task Object_Theory(string testName, ExpressionTestCaseRoot.TestCaseItem testCaseItem) =>
+        await RunTestCase(testName, new ExpressionTestCaseRoot(testCaseItem));
+
     private static async Task<ExpressionTestCaseRoot> LoadTestCase(string file, string folder)
     {
         ExpressionTestCaseRoot testCase = new();

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/shared-tests/functions/component/lookup-list.json

@@ -0,0 +1,38 @@
+{
+  "name": "Lookup a list",
+  "layouts": {
+    "Page1": {
+      "$schema": "https://altinncdn.no/schemas/json/layout/layout.schema.v1.json",
+      "data": {
+        "layout": [
+          {
+            "id": "some-component",
+            "type": "Checkboxes",
+            "dataModelBindings": {
+              "simpleBinding": "chosenValues"
+            },
+            "options": [
+              {
+                "value": "a",
+                "label": "id_KZuKMBAE5eel"
+              },
+              {
+                "value": "b",
+                "label": "id_Erk5v6GSNDu6"
+              },
+              {
+                "value": "c",
+                "label": "id_6S71AQBlLcPX"
+              }
+            ]
+          }
+        ]
+      }
+    }
+  },
+  "dataModel": {
+    "chosenValues": ["a", "c"]
+  },
+  "expression": ["component", "some-component"],
+  "expects": ["a", "c"]
+}

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/shared-tests/functions/dataModel/lookup-list.json

@@ -12,8 +12,9 @@
         "booleanList": [true, false],
         "nullList": [null, null],
         "multidimensionalList": [[[1, 2], [3, 4]], [[5, 6], [7, 8]]],
+        "objectList": [{ "a": 1 }, { "a": 2 }],
         "emptyList": [],
-        "differentTypesList": [1, "string", true, null, [null]],
+        "differentTypesList": [1, "string", true, null, [null], { "a": null }],
         "listThatLooksLikeAnExpression": ["equals", 1, 1]
       }
     }
@@ -44,6 +45,11 @@
       "expression": ["dataModel", "multidimensionalList"],
       "expects": [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
     },
+    {
+      "name": "Object list lookup",
+      "expression": ["dataModel", "objectList"],
+      "expects": [{ "a": 1 }, { "a": 2 }]
+    },
     {
       "name": "Empty list lookup",
       "expression": ["dataModel", "emptyList"],
@@ -52,7 +58,7 @@
     {
       "name": "Lookup of list with different types",
       "expression": ["dataModel", "differentTypesList"],
-      "expects": [1, "string", true, null, [null]]
+      "expects": [1, "string", true, null, [null], { "a": null }]
     },
     {
       "name": "Lookup of list that looks like an expression",