Support lists in expressions

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

@@ -1,6 +1,7 @@
 using System.Diagnostics;
 using System.Globalization;
 using System.Text.Json;
+using System.Text.Json.Nodes;
 using System.Text.RegularExpressions;
 using Altinn.App.Core.Models;
 using Altinn.App.Core.Models.Expressions;
@@ -16,7 +17,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,
@@ -131,6 +132,7 @@
             ExpressionFunction.minus => Minus(args),
             ExpressionFunction.multiply => Multiply(args),
             ExpressionFunction.divide => Divide(args),
+            ExpressionFunction.list => List(args),
             ExpressionFunction.INVALID => throw new ExpressionEvaluatorTypeErrorException(
                 $"Function {expr.Args.FirstOrDefault()} not implemented in backend {expr}"
             ),
@@ -747,7 +749,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))
@@ -789,7 +791,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))
@@ -997,6 +999,11 @@
         return positionalArguments[index.Value];
     }
 
+    private static JsonArray List(ExpressionValue[] args)
+    {
+        return new JsonArray(args.Select(a => JsonSerializer.SerializeToNode(a)).ToArray());
+    }
+
     /// <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

@@ -2,6 +2,7 @@
 using System.Globalization;
 using System.Text.Encodings.Web;
 using System.Text.Json;
+using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
 
 namespace Altinn.App.Core.Internal.Expressions;
@@ -18,8 +19,8 @@
     // 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 ExpressionValue[]? _arrayValue = null;
+    private readonly JsonArray? _arrayValue = null;
 
     /// <summary>
     /// Constructor for NULL value (structs require a public parameterless constructor)
@@ -27,7 +28,7 @@
     public ExpressionValue()
         : this(JsonValueKind.Null) { }
 
     private ExpressionValue(JsonValueKind valueKind)
     {
         ValueKind = valueKind;
     }
@@ -84,16 +85,17 @@
     }
 
     // private ExpressionValue(Dictionary<string, ExpressionValue>? value)
     // {
     //     _valueKind = value is null ? JsonValueKind.Null : JsonValueKind.Object;
     //     _objectValue = value;
     // }
 
-    // private ExpressionValue(ExpressionValue[]? value)
-    // {
-    //     _valueKind = value is null ? JsonValueKind.Null : JsonValueKind.Array;
-    //     _arrayValue = value;
-    // }
+    /// <summary>Constructor for array value</summary>
+    public ExpressionValue(JsonArray value)
+    {
+        ValueKind = JsonValueKind.Array;
+        _arrayValue = value;
+    }
 
     /// <summary>
     /// Convert a nullable boolean to ExpressionValue
@@ -113,12 +115,12 @@
     // /// <summary>
     // /// Convert a Dictionary to ExpressionValue
     // /// </summary>
     // public static implicit operator ExpressionValue(Dictionary<string, ExpressionValue>? value) => new(value);
-    //
-    // /// <summary>
-    // /// Convert an array to ExpressionValue
-    // /// </summary>
-    // public static implicit operator ExpressionValue(ExpressionValue[]? value) => new(value);
+
+    /// <summary>
+    /// Convert an array to ExpressionValue
+    /// </summary>
+    public static implicit operator ExpressionValue(JsonArray value) => new(value);
 
     /// <summary>
     /// Convert any of the supported CLR types to an expressionTypeUnion
@@ -172,6 +174,17 @@
                     '"'
                 ) // Trim quotes to match the string representation
             ,
+            JsonArray jsonArrayValue => jsonArrayValue,
+            _ => ToJsonArrayOrNull(value),
+        };
+    }
+
+    private static ExpressionValue ToJsonArrayOrNull(object? value)
+    {
+        var node = JsonSerializer.SerializeToNode(value);
+        return node switch
+        {
+            JsonArray jsonArray => jsonArray,
             _ => Null,
         };
     }
@@ -190,7 +203,7 @@
             JsonValueKind.String => String,
             JsonValueKind.Number => Number,
             // JsonValueKind.Object => Object,
-            // JsonValueKind.Array => Array,
+            JsonValueKind.Array => Array,
             _ => throw new InvalidOperationException("Invalid value kind"),
         };
 
@@ -215,7 +228,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"),
@@ -238,21 +251,22 @@
 
     // 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}"
     //        ),
     //     };
-    //
-    // public ExpressionValue[] Array =>
-    //     _valueKind switch
-    //     {
-    //         JsonValueKind.Array => _arrayValue ?? throw new UnreachableException($"{this} is not an array"),
-    //         _ => throw new InvalidCastException(
-    //            $"The .Array property can't be used on an expression value that represent a {_valueKind}"
-    //        ),
-    //     };
+
+    /// <summary>Get the value as an array (or throw if it isn't an array ValueKind)</summary>
+    public JsonArray Array =>
+        ValueKind switch
+        {
+            JsonValueKind.Array => _arrayValue ?? throw new UnreachableException($"{this} is not an array"),
+            _ => throw new InvalidCastException(
+                $"The .Array property can't be used on an expression value that represent a {ValueKind}"
+            ),
+        };
 
     /// <summary>
     /// Get the value as it would be serialized to JSON
@@ -263,12 +277,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),
             _ => throw new InvalidOperationException($"Invalid value kind {ValueKind}"),
         };
 
     /// <summary>
@@ -326,7 +340,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
@@ -355,7 +369,7 @@
     {
         throw new NotImplementedException("GetHashCode is not implemented for ExpressionValue");
         // return ValueKind switch
         // {
         //     JsonValueKind.Null => 0,
         //     JsonValueKind.True => 1,
         //     JsonValueKind.False => 0,
@@ -472,7 +486,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;
@@ -589,7 +603,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)
@@ -621,18 +635,25 @@
             JsonTokenType.Number => reader.GetDouble(),
             JsonTokenType.Null => ExpressionValue.Null,
             // JsonTokenType.StartObject => ReadObject(ref reader),
-            // JsonTokenType.StartArray => ReadArray(ref reader),
+            JsonTokenType.StartArray => ReadArray(ref reader, options),
             _ => throw new JsonException(),
         };
     }
 
-    // private ExpressionValue ReadArray(ref Utf8JsonReader reader)
-    // {
-    //     throw new NotImplementedException();
-    // }
-    //
+    private static ExpressionValue ReadArray(ref Utf8JsonReader reader, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.StartArray)
+        {
+            throw new JsonException("Expected StartArray token.");
+        }
+        var values =
+            JsonSerializer.Deserialize<JsonArray>(ref reader, options)
+            ?? throw new JsonException("Expected JSON array value.");
+        return new ExpressionValue(values);
+    }
+
     // private ExpressionValue ReadObject(ref Utf8JsonReader reader)
     // {
     //     throw new NotImplementedException();
     // }
 
@@ -658,11 +679,11 @@
                 writer.WriteNumberValue(value.Number);
                 break;
             // case JsonValueKind.Object:
             //     JsonSerializer.Serialize(writer, value.Object, options);
             //     break;
-            // case JsonValueKind.Array:
-            //     JsonSerializer.Serialize(writer, value.Array, options);
-            //     break;
+            case JsonValueKind.Array:
+                JsonSerializer.Serialize(writer, value.Array, options);
+                break;
             default:
                 throw new JsonException();
         }

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

@@ -225,4 +225,7 @@ public enum ExpressionFunction
     /// Divide numbers. Must be numeric values.
     /// </summary>
     divide,
+
+    /// <summary>Create a list from the arguments.</summary>
+    list,
 }

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

@@ -41,7 +41,7 @@ public ExpressionTestCaseRoot() { }
     public string? Name { get; set; }
 
     [JsonPropertyName("expression")]
-    public Expression Expression { get; set; }
+    public Expression? Expression { get; set; }
 
     [JsonPropertyName("context")]
     public ComponentContextForTestSpec? Context { get; set; }

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

@@ -93,7 +93,7 @@ private async Task RunTestCase(string testName, string folder)
                 {
                     await ExpressionEvaluator.EvaluateExpression(
                         state,
-                        test.Expression,
+                        test.Expression!.Value,
                         await test.GetContextOrNull(state)
                     );
                 };
@@ -107,7 +107,7 @@ await test.GetContextOrNull(state)
 
         var result = await ExpressionEvaluator.EvaluateExpression(
             state,
-            test.Expression,
+            test.Expression!.Value,
             await test.GetContextOrNull(state)!
         );
 

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

@@ -227,6 +227,11 @@ public async Task Divide_Theory(string testName, ExpressionTestCaseRoot.TestCase
     [SharedTest("round")]
     public async Task Round_Theory(string testName, string folder) => await RunTestCase(testName, folder);
 
+    [Theory]
+    [SharedTestCases("list")]
+    public async Task List_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();
@@ -395,17 +400,20 @@ private async Task RunTestCase(string testName, ExpressionTestCaseRoot test)
 
         test.ParsingException.Should().BeNull("Loading of test failed");
 
-        await RunTestCaseItem(
-            new ExpressionTestCaseRoot.TestCaseItem()
-            {
-                Expects = test.Expects,
-                Expression = test.Expression,
-                ExpectsFailure = test.ExpectsFailure,
-            },
-            state,
-            context,
-            positionalArguments
-        );
+        if (test.Expression != null)
+        {
+            await RunTestCaseItem(
+                new ExpressionTestCaseRoot.TestCaseItem()
+                {
+                    Expects = test.Expects,
+                    Expression = (Expression)test.Expression,
+                    ExpectsFailure = test.ExpectsFailure,
+                },
+                state,
+                context,
+                positionalArguments
+            );
+        }
 
         if (test.TestCases != null)
         {

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

@@ -59,7 +59,11 @@ public async Task Simple_Theory(string testName, string folder)
             var state = dataAccessor.GetLayoutEvaluatorState();
             Assert.NotNull(state);
 
-            await ExpressionEvaluator.EvaluateExpression(state, test.Expression, await test.GetContextOrNull(state));
+            await ExpressionEvaluator.EvaluateExpression(
+                state,
+                test.Expression!.Value,
+                await test.GetContextOrNull(state)
+            );
         };
         (await act.Should().ThrowAsync<Exception>()).WithMessage(testCase.ExpectsFailure + "*");
     }

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"]
+}