Implemented 'With' function to add a means of saving variables

Author: Florian Kroenert

src/lib/Xrm.Oss.XTL.Interpreter/FunctionHandlers.cs

@@ -1413,6 +1413,64 @@ private static Entity FetchSnippet(string name, string filter, Entity primary, I
             return new ValueExpression(value?.ToString(), value);
         };
 
+        /// <summary>
+        /// Defines temporary variables for use in an expression.
+        /// Usage: With({ x: Value("amount"), y: 10 }, (x, y) => FormatString("$0 + $1", x, y))
+        /// </summary>
+        public static FunctionHandler With = (primary, service, tracing, interpreterConfig, parameters) =>
+        {
+            if (parameters.Count < 2)
+            {
+                throw new InvalidPluginExecutionException("With needs a dictionary of variables and a lambda expression");
+            }
+
+            // First parameter: dictionary of variables
+            var variables = CheckedCast<Dictionary<string, object>>(
+                parameters[0].Value, 
+                "First parameter of With must be a dictionary"
+            );
+
+            // Second parameter: lambda expression
+            var lambdaParam = parameters[1];
+            var lambdaFunc = lambdaParam.Value as Func<List<ValueExpression>, ValueExpression>;
+            
+            if (lambdaFunc == null)
+            {
+                throw new InvalidPluginExecutionException(
+                    "Second parameter of With must be a lambda expression"
+                );
+            }
+
+            // Get lambda parameter names
+            if (lambdaParam.Args == null)
+            {
+                throw new InvalidPluginExecutionException(
+                    "Lambda expression must have named parameters"
+                );
+            }
+
+            var lambdaParamNames = lambdaParam.Args.Keys.ToList();
+
+            // Check all required variables are provided
+            var missingVars = lambdaParamNames.Where(name => !variables.ContainsKey(name)).ToList();
+            if (missingVars.Any())
+            {
+                throw new InvalidPluginExecutionException(
+                    $"Lambda parameters {string.Join(", ", missingVars.Select(v => $"'{v}'"))} not found in With dictionary"
+                );
+            }
+
+            // Map dictionary values to lambda parameters in correct order
+            var args = lambdaParamNames
+                .Select(name => new ValueExpression(
+                    variables[name]?.ToString() ?? string.Empty, 
+                    variables[name]
+                ))
+                .ToList();
+
+            return lambdaFunc(args);
+        };
+
         public static FunctionHandler GptPrompt = (primary, service, tracing, interpreterConfig, parameters) =>
         {
             if (interpreterConfig == null || string.IsNullOrEmpty(interpreterConfig.OpenAIAccessToken))

src/lib/Xrm.Oss.XTL.Interpreter/ValueExpression.cs

@@ -8,6 +8,7 @@ public class ValueExpression
     {
         private Lazy<string> _text;
         private Lazy<object> _value;
+        public Dictionary<string, ValueExpression> Args { get; private set; }
 
         public string Text
         {
@@ -41,6 +42,7 @@ public ValueExpression(Func<List<ValueExpression>, ValueExpression> expression,
         {
             _text = new Lazy<string>(() => string.Empty);
             _value = new Lazy<object>(() => expression);
+            Args = args;
         }
     }
 }

src/lib/Xrm.Oss.XTL.Interpreter/XTLInterpreter.cs

@@ -67,7 +67,8 @@ public class XTLInterpreter
             { "Static", FunctionHandlers.Static },
             { "Substring", FunctionHandlers.Substring },
             { "Union", FunctionHandlers.Union },
-            { "Value", FunctionHandlers.GetValue }
+            { "Value", FunctionHandlers.GetValue },
+            { "With", FunctionHandlers.With }
         };
 
         public XTLInterpreter(string input, Entity primary, InterpreterConfig interpreterConfig, IOrganizationService service, ITracingService tracing)

src/test/Xrm.Oss.XTL.Interpreter.Tests/XTLInterpreterTests.cs

@@ -468,6 +468,44 @@ public void It_Should_Execute_Lambdas_On_Filter()
             Assert.That(result, Is.EqualTo("Lord of"));
         }
 
+        [Test]
+        public void It_Should_Make_Variables_Available_In_With()
+        {
+            var context = new XrmFakedContext();
+            var service = context.GetFakedOrganizationService();
+            var tracing = context.GetFakeTracingService();
+
+            var formula = "With({ question: 'What is the answer to the Ultimate Question of Life, the Universe, and Everything', answer: 42 }, ( question, answer ) => FormatString('$0?\n- $1', question, answer))";
+            var result = new XTLInterpreter(formula, new Entity(), null, service, tracing).Produce();
+
+            Assert.That(result, Is.EqualTo("What is the answer to the Ultimate Question of Life, the Universe, and Everything?\n- 42"));
+        }
+
+        [Test]
+        public void It_Should_Not_Rely_On_Parameter_Order_In_With()
+        {
+            var context = new XrmFakedContext();
+            var service = context.GetFakedOrganizationService();
+            var tracing = context.GetFakeTracingService();
+
+            var formula = "With({ question: 'What is the answer to the Ultimate Question of Life, the Universe, and Everything', answer: 42 }, ( answer, question ) => FormatString('$0?\n- $1', question, answer))";
+            var result = new XTLInterpreter(formula, new Entity(), null, service, tracing).Produce();
+
+            Assert.That(result, Is.EqualTo("What is the answer to the Ultimate Question of Life, the Universe, and Everything?\n- 42"));
+        }
+
+        [Test]
+        public void It_Should_Throw_On_Missing_Parameter_In_With()
+        {
+            var context = new XrmFakedContext();
+            var service = context.GetFakedOrganizationService();
+            var tracing = context.GetFakeTracingService();
+
+            var formula = "With({ answer: 42 }, ( answer, question ) => FormatString('$0?\n- $1', question, answer))";
+
+            Assert.That(() => new XTLInterpreter(formula, new Entity(), null, service, tracing).Produce(), Throws.Exception);
+        }
+
         [Test]
         public void Coalesce_Should_Return_First_Non_Null_Value()
         {