Add Jmespath expression function

Directory.Packages.props

@@ -20,6 +20,7 @@
     <PackageVersion Include="CSharpier.Core" Version="1.2.6" />
     <PackageVersion Include="CSharpier.MsBuild" Version="1.2.6" />
     <PackageVersion Include="FluentAssertions" Version="7.2.2" />
+    <PackageVersion Include="JmesPath.Net" Version="1.1.0" />
     <PackageVersion Include="JsonPatch.Net" Version="4.0.1" />
     <PackageVersion Include="JWTCookieAuthentication" Version="3.0.1" />
     <PackageVersion Include="Microsoft.ApplicationInsights.AspNetCore" Version="2.23.0" />
@@ -80,4 +81,4 @@
     <PackageVersion Include="Polly.Extensions" Version="8.6.6" />
     <PackageVersion Include="Polly.Testing" Version="8.6.6" />
   </ItemGroup>
-</Project>
+</Project>

src/Altinn.App.Core/Altinn.App.Core.csproj

@@ -33,6 +33,7 @@
     <PackageReference Include="Altinn.Common.PEP"/>
     <PackageReference Include="Altinn.Platform.Models"/>
     <PackageReference Include="Altinn.Platform.Storage.Interface"/>
+    <PackageReference Include="JmesPath.Net"/>
     <PackageReference Include="JsonPatch.Net"/>
     <PackageReference Include="Microsoft.ApplicationInsights.AspNetCore"/>
     <PackageReference Include="Microsoft.Extensions.Caching.Hybrid"/>

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

@@ -134,6 +134,7 @@ internal static async Task<ExpressionValue> EvaluateExpression_internal(
             ExpressionFunction.divide => Divide(args),
             ExpressionFunction.list => List(args),
             ExpressionFunction.@object => Object(args),
+            ExpressionFunction.jmespath => Jmespath(args),
             ExpressionFunction.INVALID => throw new ExpressionEvaluatorTypeErrorException(
                 $"Function {expr.Args.FirstOrDefault()} not implemented in backend {expr}"
             ),
@@ -1010,6 +1011,11 @@ private static JsonObject Object(ExpressionValue[] args)
         return new ObjectFunctionEvaluator(args).Evaluate();
     }
 
+    private static ExpressionValue Jmespath(ExpressionValue[] args)
+    {
+        return new JmespathFunctionEvaluator(args).Evaluate();
+    }
+
     /// <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

@@ -194,6 +194,23 @@ private static ExpressionValue ToJsonNodeOrNull(object? value)
         };
     }
 
+    /// <summary>Convert a JsonElement to ExpressionValue.</summary>
+    public static ExpressionValue FromJsonElement(JsonElement element)
+    {
+        return element.ValueKind switch
+        {
+            JsonValueKind.Null => Null,
+            JsonValueKind.Undefined => Undefined,
+            JsonValueKind.True => True,
+            JsonValueKind.False => False,
+            JsonValueKind.String => element.GetString(),
+            JsonValueKind.Number => element.GetDouble(),
+            JsonValueKind.Object => element.Deserialize<JsonObject>() ?? Null,
+            JsonValueKind.Array => element.Deserialize<JsonArray>() ?? Null,
+            _ => throw new InvalidOperationException($"Invalid JsonElement with ValueKind {element.ValueKind}"),
+        };
+    }
+
     /// <summary>
     /// Convert the value to the relevant CLR type
     /// </summary>

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

@@ -0,0 +1,44 @@
+using System.Text.Json;
+using DevLab.JmesPath;
+
+namespace Altinn.App.Core.Internal.Expressions;
+
+internal sealed class JmespathFunctionEvaluator
+{
+    private readonly ExpressionValue[] _args;
+
+    public JmespathFunctionEvaluator(ExpressionValue[] args) => _args = args;
+
+    public ExpressionValue Evaluate()
+    {
+        if (_args.Length != 2)
+        {
+            throw new ExpressionEvaluatorTypeErrorException($"Expected 2 argument(s), got {_args.Length}");
+        }
+        if (_args[1].ValueKind != JsonValueKind.String)
+        {
+            throw new ExpressionEvaluatorTypeErrorException($"Expected argument to be string, got {_args[1]}");
+        }
+        return Implementation(_args[0], _args[1].String);
+    }
+
+    private static ExpressionValue Implementation(ExpressionValue data, string query)
+    {
+        string resultAsString = VerifyAndRunQuery(data, query);
+        JsonElement result = JsonSerializer.Deserialize<JsonElement>(resultAsString);
+        return ExpressionValue.FromJsonElement(result);
+    }
+
+    private static string VerifyAndRunQuery(ExpressionValue data, string query)
+    {
+        JmesPath jmesPath = new();
+        try
+        {
+            return jmesPath.Transform(data.ToString(), query);
+        }
+        catch (Exception exception)
+        {
+            throw new ExpressionEvaluatorTypeErrorException($"Jmespath error: \"{exception.Message}\"");
+        }
+    }
+}

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

@@ -233,4 +233,7 @@ public enum ExpressionFunction
 #pragma warning disable CA1720
     @object,
 #pragma warning restore CA1720
+
+    /// <summary>Run a Jmespath query on the arguments</summary>
+    jmespath,
 }

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

@@ -237,6 +237,11 @@ public async Task List_Theory(string testName, ExpressionTestCaseRoot.TestCaseIt
     public async Task Object_Theory(string testName, ExpressionTestCaseRoot.TestCaseItem testCaseItem) =>
         await RunTestCase(testName, new ExpressionTestCaseRoot(testCaseItem));
 
+    [Theory]
+    [SharedTestCases("jmespath")]
+    public async Task Jmespath_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/jmespath/jmespath.json

@@ -0,0 +1,150 @@
+{
+  "name": "jmespath",
+  "testCases": [
+    {
+      "name": "Works with a simple property query that returns a string",
+      "expression": ["jmespath", ["object", "name", "Kari"], "name"],
+      "expects": "Kari"
+    },
+    {
+      "name": "Works with a simple property query that returns a number",
+      "expression": ["jmespath", ["object", "ageInYears", 18], "ageInYears"],
+      "expects": 18
+    },
+    {
+      "name": "Works with a simple property query that returns a boolean",
+      "expression": ["jmespath", ["object", "likesIceCream", true], "likesIceCream"],
+      "expects": true
+    },
+    {
+      "name": "Works with a simple property query that returns null",
+      "expression": ["jmespath", ["object", "favouriteColour", null], "favouriteColour"],
+      "expects": null
+    },
+    {
+      "name": "Works with a simple property query that returns an object",
+      "expression": [
+        "jmespath",
+        [
+          "object",
+          "person",
+          [
+            "object",
+            "name", "Kari",
+            "ageInYears", 18,
+            "likesIceCream", true,
+            "favouriteColour", null
+          ]
+        ],
+        "person"
+      ],
+      "expects": {
+        "name": "Kari",
+        "ageInYears": 18,
+        "likesIceCream": true,
+        "favouriteColour": null
+      }
+    },
+    {
+      "name": "Works with a simple property query that returns a list",
+      "expression": [
+        "jmespath",
+        [
+          "object",
+          "colours",
+          ["list", "red", "green", "blue"]
+        ],
+        "colours"
+      ],
+      "expects": ["red", "green", "blue"]
+    },
+    {
+      "name": "Works with a simple property query on a list of objects",
+      "expression": [
+        "jmespath",
+        [
+          "list",
+          ["object", "name", "Ola", "ageInYears", 30],
+          ["object", "name", "Kari", "ageInYears", 18],
+          ["object", "name", "Knut", "ageInYears", 16]
+        ],
+        "[].name"
+      ],
+      "expects": ["Ola", "Kari", "Knut"]
+    },
+    {
+      "name": "Works with filtering",
+      "expression": [
+        "jmespath",
+        [
+          "list",
+          ["object", "name", "Ola", "ageInYears", 30],
+          ["object", "name", "Kari", "ageInYears", 18],
+          ["object", "name", "Knut", "ageInYears", 16]
+        ],
+        "[?ageInYears>=`18`].name"
+      ],
+      "expects": ["Ola", "Kari"]
+    },
+    {
+      "name": "Works with the current-node token",
+      "expression": ["jmespath", ["list", "something"], "@"],
+      "expects": ["something"]
+    },
+    {
+      "name": "Works with literal expressions",
+      "expression": ["jmespath", ["object"], "'Lorem ipsum'"],
+      "expects": "Lorem ipsum"
+    },
+    {
+      "name": "Works with functions",
+      "expression": ["jmespath", ["object"], "abs(`-1`)"],
+      "expects": 1
+    },
+    {
+      "name": "Returns null when no results are found",
+      "expression": ["jmespath", ["object", "name", "Kari", "ageInYears", 18], "city"],
+      "expects": null
+    },
+    {
+      "name": "Accepts string input",
+      "expression": ["jmespath", "This is a string", "@"],
+      "expects": "This is a string"
+    },
+    {
+      "name": "Accepts number input",
+      "expression": ["jmespath", 12, "@"],
+      "expects": 12
+    },
+    {
+      "name": "Accepts boolean input",
+      "expression": ["jmespath", true, "@"],
+      "expects": true
+    },
+    {
+      "name": "Accepts null input",
+      "expression": ["jmespath", null, "@"],
+      "expects": null
+    },
+    {
+      "name": "Fails when query is invalid",
+      "expression": ["jmespath", ["object", "name", "Kari", "ageInYears", 18], "#"],
+      "expectsFailure": "Jmespath error"
+    },
+    {
+      "name": "Fails when no arguments are present",
+      "expression": ["jmespath"],
+      "expectsFailure": "Expected 2 argument(s), got 0"
+    },
+    {
+      "name": "Fails when the query is null",
+      "expression": ["jmespath", ["object"], null],
+      "expectsFailure": "Expected argument to be string"
+    },
+    {
+      "name": "Fails when the query is neither a string nor null",
+      "expression": ["jmespath", ["object", "name", "Kari", "ageInYears", 18], ["object"]],
+      "expectsFailure": "Expected argument to be string"
+    }
+  ]
+}

test/Altinn.App.Core.Tests/PublicApiTests.PublicApi_ShouldNotChange_Unintentionally.verified.txt

@@ -3255,6 +3255,7 @@ namespace Altinn.App.Core.Internal.Expressions
         public string? ToStringForText() { }
         public bool TryDeserialize(System.Type type, out object? result) { }
         public bool TryDeserialize<T>(out T? result) { }
+        public static Altinn.App.Core.Internal.Expressions.ExpressionValue FromJsonElement(System.Text.Json.JsonElement element) { }
         public static Altinn.App.Core.Internal.Expressions.ExpressionValue FromObject(object? value) { }
         public static Altinn.App.Core.Internal.Expressions.ExpressionValue op_Implicit(System.Text.Json.Nodes.JsonArray value) { }
         public static Altinn.App.Core.Internal.Expressions.ExpressionValue op_Implicit(System.Text.Json.Nodes.JsonObject value) { }
@@ -4725,6 +4726,7 @@ namespace Altinn.App.Core.Models.Expressions
         divide = 40,
         list = 41,
         @object = 42,
+        jmespath = 43,
     }
 }
 namespace Altinn.App.Core.Models.Layout.Components.Base