Add function param support

GDLMadushanka · GDLMadushanka · commit 6467ccdf28d9 · 2024-11-27T16:08:08.000+05:30
Add function param supprot and other improvements. Related to wso2/product-micro-integrator/issues/3749
diff --git a/modules/core/src/main/java/org/apache/synapse/SynapseConstants.java b/modules/core/src/main/java/org/apache/synapse/SynapseConstants.java
@@ -678,6 +678,7 @@ public enum ENDPOINT_TIMEOUT_TYPE { ENDPOINT_TIMEOUT, GLOBAL_TIMEOUT, HTTP_CONNE
     public static final String  AXIS2 = "axis2";
     public static final String  QUERY_PARAM = "queryParams";
     public static final String  URI_PARAM = "uriParams";
+    public static final String  FUNC_PARAM = "functionParams";
 
     public static final String  UNKNOWN = "unknown";
     public static final String  VAULT_LOOKUP = "wso2:vault-lookup('";
diff --git a/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/ArgumentListNode.java b/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/ArgumentListNode.java
@@ -40,7 +40,7 @@ public List<ExpressionNode> getArguments() {
     }
 
     @Override
-    public ExpressionResult evaluate(EvaluationContext context) {
+    public ExpressionResult evaluate(EvaluationContext context, boolean isObjectValue) {
         return null;
     }
 
diff --git a/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/ArrayIndexNode.java b/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/ArrayIndexNode.java
@@ -35,14 +35,14 @@ public ArrayIndexNode(ArgumentListNode arguments, char separator) {
     }
 
     @Override
-    public ExpressionResult evaluate(EvaluationContext context) {
+    public ExpressionResult evaluate(EvaluationContext context, boolean isObjectValue) {
         List<String> indexList = new ArrayList<>();
         for (ExpressionNode index : indexArray) {
             if (index == null) {
                 indexList.add("");
                 continue;
             }
-            ExpressionResult result = index.evaluate(context);
+            ExpressionResult result = index.evaluate(context, isObjectValue);
             if (result != null) {
                 indexList.add(result.asString());
             }
diff --git a/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/BinaryOperationNode.java b/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/BinaryOperationNode.java
@@ -71,9 +71,9 @@ public BinaryOperationNode(ExpressionNode left, String operator, ExpressionNode
     }
 
     @Override
-    public ExpressionResult evaluate(EvaluationContext context) throws EvaluationException {
-        ExpressionResult leftValue = left.evaluate(context);
-        ExpressionResult rightValue = right.evaluate(context);
+    public ExpressionResult evaluate(EvaluationContext context, boolean isObjectValue) throws EvaluationException {
+        ExpressionResult leftValue = left.evaluate(context, isObjectValue);
+        ExpressionResult rightValue = right.evaluate(context, isObjectValue);
         if ((leftValue == null || rightValue == null) &&
                 (operator != Operator.EQUALS && operator != Operator.NOT_EQUALS)) {
             throw new EvaluationException("Null inputs for " + operator + " operation: " + leftValue
diff --git a/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/ConditionalExpressionNode.java b/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/ConditionalExpressionNode.java
@@ -38,13 +38,14 @@ public ConditionalExpressionNode(ExpressionNode condition, ExpressionNode trueEx
     }
 
     @Override
-    public ExpressionResult evaluate(EvaluationContext context) {
-        ExpressionResult conditionResult = condition.evaluate(context);
+    public ExpressionResult evaluate(EvaluationContext context, boolean isObjectValue) throws EvaluationException {
+        ExpressionResult conditionResult = condition.evaluate(context, isObjectValue);
         if (conditionResult == null || conditionResult.isNull()) {
             throw new EvaluationException("Condition is null in conditional expression");
         }
         if (conditionResult.isBoolean()) {
-            return conditionResult.asBoolean() ? trueExpression.evaluate(context) : falseExpression.evaluate(context);
+            return conditionResult.asBoolean() ? trueExpression.evaluate(context, isObjectValue)
+                    : falseExpression.evaluate(context, isObjectValue);
         } else {
             throw new EvaluationException("Condition is not a boolean in conditional expression");
         }
diff --git a/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/ExpressionNode.java b/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/ExpressionNode.java
@@ -25,5 +25,5 @@
  * Represents a node in the AST.
  */
 public interface ExpressionNode {
-    ExpressionResult evaluate(EvaluationContext context) throws EvaluationException;
+    ExpressionResult evaluate(EvaluationContext context, boolean isObjectValue) throws EvaluationException;
 }
diff --git a/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/ExpressionResult.java b/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/ExpressionResult.java
@@ -27,8 +27,11 @@
 import com.google.gson.JsonSyntaxException;
 import com.google.gson.internal.LazilyParsedNumber;
 import org.apache.axiom.om.OMElement;
+import org.apache.axiom.om.OMNode;
 import org.apache.synapse.util.synapse.expression.exception.EvaluationException;
 
+import java.util.List;
+
 /**
  * This class represents the result of an expression evaluation.
  * It can hold values of different types such as String, Number, Boolean, JsonElement, and null.
@@ -44,7 +47,11 @@ public ExpressionResult(String value) {
         this.value = value;
     }
 
-    public ExpressionResult(OMElement value) {
+    public ExpressionResult(OMNode value) {
+        this.value = value;
+    }
+
+    public ExpressionResult(List value) {
         this.value = value;
     }
 
diff --git a/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/FilterExpressionNode.java b/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/FilterExpressionNode.java
@@ -41,10 +41,10 @@ public FilterExpressionNode(String expression, Map<String, ExpressionNode> argum
      * Not evaluating here.
      */
     @Override
-    public ExpressionResult evaluate(EvaluationContext context) {
+    public ExpressionResult evaluate(EvaluationContext context, boolean isObjectValue) {
         for (Map.Entry<String, ExpressionNode> entry : arguments.entrySet()) {
             if (entry.getValue() != null) {
-                ExpressionResult result = entry.getValue().evaluate(context);
+                ExpressionResult result = entry.getValue().evaluate(context, isObjectValue);
                 if (result != null) {
                     String regex = ExpressionUtils.escapeSpecialCharacters(entry.getKey());
                     String resultString = result.asString();
diff --git a/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/HeadersAndPropertiesAccessNode.java b/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/HeadersAndPropertiesAccessNode.java
@@ -34,8 +34,7 @@ public enum Type {
         HEADER,
         PROPERTY,
         CONFIG,
-        QUERY_PARAM,
-        PATH_PARAM
+        FUNCTION_PARAM
     }
 
     private final Type type;
@@ -56,9 +55,9 @@ public HeadersAndPropertiesAccessNode(ExpressionNode node, String scope) {
     }
 
     @Override
-    public ExpressionResult evaluate(EvaluationContext context) {
+    public ExpressionResult evaluate(EvaluationContext context, boolean isObjectValue) throws EvaluationException {
         if (key != null) {
-            String name = key.evaluate(context).asString();
+            String name = key.evaluate(context, isObjectValue).asString();
             Object value;
             if (Type.HEADER.equals(type)) {
                 value = context.getHeader(name);
@@ -68,6 +67,8 @@ public ExpressionResult evaluate(EvaluationContext context) {
                 } catch (ResolverException e) {
                     throw new EvaluationException("The value of the key:[" + name + "] is null");
                 }
+            } else if (Type.FUNCTION_PARAM.equals(type)) {
+                value = context.getFunctionParam(name);
             } else {
                 if (SynapseConstants.URI_PARAM.equals(scope)) {
                     value = context.getProperty("uri.var." + name, SynapseConstants.SYNAPSE);
@@ -77,7 +78,11 @@ public ExpressionResult evaluate(EvaluationContext context) {
                     value = context.getProperty(name, scope);
                 }
             }
-            return new ExpressionResult(value != null ? value.toString() : null);
+            if (value != null) {
+                return new ExpressionResult(value.toString());
+            } else {
+                throw new EvaluationException("Could not fetch the value of the key: " + name);
+            }
         }
         throw new EvaluationException("Key cannot be null when accessing headers or properties");
     }
diff --git a/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/LiteralNode.java b/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/LiteralNode.java
@@ -50,7 +50,7 @@ public LiteralNode(ArgumentListNode value, Type type) {
     }
 
     @Override
-    public ExpressionResult evaluate(EvaluationContext context) {
+    public ExpressionResult evaluate(EvaluationContext context, boolean isObjectValue) {
         switch (type) {
             case NUMBER:
                 return parseNumber(value);
@@ -61,7 +61,7 @@ public ExpressionResult evaluate(EvaluationContext context) {
             case NULL:
                 return null;
             case ARRAY:
-                return parseArray(context);
+                return parseArray(context, isObjectValue);
             default:
                 throw new IllegalArgumentException("Unsupported type: " + type);
         }
@@ -83,10 +83,10 @@ private ExpressionResult parseNumber(String value) {
         }
     }
 
-    private ExpressionResult parseArray(EvaluationContext context) {
+    private ExpressionResult parseArray(EvaluationContext context, boolean isObjectValue) {
         JsonArray jsonArray = new JsonArray();
         for (ExpressionNode expressionNode : parameterList.getArguments()) {
-            ExpressionResult result = expressionNode.evaluate(context);
+            ExpressionResult result = expressionNode.evaluate(context, isObjectValue);
             if (result.getType().equals(JsonElement.class)) {
                 jsonArray.add(result.asJsonElement());
             } else if (result.isInteger()) {
diff --git a/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/PayloadAccessNode.java b/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/PayloadAccessNode.java
@@ -38,9 +38,11 @@
 import org.apache.synapse.util.synapse.expression.context.EvaluationContext;
 import org.apache.synapse.util.synapse.expression.exception.EvaluationException;
 import org.apache.synapse.util.synapse.expression.utils.ExpressionUtils;
+import org.jaxen.JaxenException;
 
 import java.io.IOException;
 import java.util.EnumSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
@@ -90,32 +92,47 @@ public Set<Option> options() {
     }
 
     @Override
-    public ExpressionResult evaluate(EvaluationContext context) {
+    public ExpressionResult evaluate(EvaluationContext context, boolean isObjectValue) throws EvaluationException {
         if (expression.startsWith(SynapseConstants.PAYLOAD)) {
             expression = SynapseConstants.PAYLOAD_$ + expression.substring(SynapseConstants.PAYLOAD.length());
         }
 
         for (Map.Entry<String, ExpressionNode> entry : arguments.entrySet()) {
             Optional.ofNullable(entry.getValue())
-                    .map(value -> value.evaluate(context))
+                    .map(value -> value.evaluate(context, isObjectValue))
                     .ifPresent(result -> processResult(entry, result));
         }
 
-        Object result = null;
+        Object result;
         switch (type) {
             case PAYLOAD:
                 try {
-                    result = context.getPayload();
+                    result = context.getPayload(isObjectValue);
                     if (result == null) {
                         throw new EvaluationException("Could not find a JSON payload to evaluate the expression: "
                                 + expression);
                     }
-                    result = JsonPath.parse(context.getPayload().toString()).read(expression);
+                    if (context.isJSON()) {
+                        result = JsonPath.parse(result.toString()).read(expression);
+                    } else {
+                        if (expression.equals(SynapseConstants.PAYLOAD_$)) {
+                            // we only get a list result in XPATH evaluation
+                            if (isObjectValue && result instanceof List) {
+                                return new ExpressionResult((List) result);
+                            } else {
+                                return new ExpressionResult(result.toString());
+                            }
+                        }
+                        throw new EvaluationException("Could not evaluate JSONPath expression: " + expression
+                                + " on non-JSON payload");
+                    }
                 } catch (PathNotFoundException e) {
                     // convert jsonPath error to native one
                     throw new EvaluationException(e.getMessage());
                 } catch (IOException e) {
                     throw new EvaluationException("Error while parsing payload");
+                } catch (JaxenException e) {
+                    throw new EvaluationException("Error while retrieving payload");
                 }
                 break;
             case VARIABLE:
@@ -140,7 +157,7 @@ public ExpressionResult evaluate(EvaluationContext context) {
                 }
                 break;
             case REGISTRY:
-                ExpressionResult registryValue = predefinedFunctionNode.evaluate(context);
+                ExpressionResult registryValue = predefinedFunctionNode.evaluate(context, isObjectValue);
                 try {
                     if (registryValue == null) {
                         throw new EvaluationException("Could not find a JSON payload to evaluate the expression: " + expression);
@@ -158,7 +175,7 @@ public ExpressionResult evaluate(EvaluationContext context) {
             case ARRAY:
             case OBJECT:
                 expression = expression.startsWith(".") ? "$" + expression : "$." + expression;
-                ExpressionResult objFuncResult = predefinedFunctionNode.evaluate(context);
+                ExpressionResult objFuncResult = predefinedFunctionNode.evaluate(context, isObjectValue);
                 try {
                     result = JsonPath.parse(objFuncResult.asJsonElement()).read(expression);
                 } catch (PathNotFoundException e) {
diff --git a/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/PredefinedFunctionNode.java b/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/PredefinedFunctionNode.java
@@ -19,6 +19,7 @@
 
 import com.google.gson.JsonArray;
 import com.google.gson.JsonPrimitive;
+import org.apache.axiom.om.OMNode;
 import org.apache.synapse.SynapseConstants;
 import org.apache.synapse.util.synapse.expression.context.EvaluationContext;
 import org.apache.synapse.util.synapse.expression.exception.EvaluationException;
@@ -54,15 +55,15 @@ public PredefinedFunctionNode(ArgumentListNode arguments, String functionName) {
     }
 
     @Override
-    public ExpressionResult evaluate(EvaluationContext context) {
+    public ExpressionResult evaluate(EvaluationContext context, boolean isObjectValue) {
         if (arguments.isEmpty()) {
             return handleNoArgumentFunctions();
         } else if (arguments.size() == 1) {
-            return handleSingleArgumentFunctions(context);
+            return handleSingleArgumentFunctions(context, isObjectValue);
         } else if (arguments.size() == 2) {
-            return handleDoubleArgumentFunctions(context);
+            return handleDoubleArgumentFunctions(context, isObjectValue);
         } else if (arguments.size() == 3) {
-            return handleTripleArgumentFunctions(context);
+            return handleTripleArgumentFunctions(context, isObjectValue);
         }
         throw new EvaluationException("Invalid number of arguments: " + arguments.size()
                 + " provided for the function: " + functionName);
@@ -75,11 +76,11 @@ private ExpressionResult handleNoArgumentFunctions() {
         throw new EvaluationException("Invalid function: " + functionName + " with no arguments");
     }
 
-    private ExpressionResult handleSingleArgumentFunctions(EvaluationContext context) {
+    private ExpressionResult handleSingleArgumentFunctions(EvaluationContext context, boolean isObjectValue) {
         ExpressionResult result = null;
         // do not evaluate the source for exists function - since we need to catch the exception
         if (!functionName.equals(SynapseConstants.EXISTS)) {
-            result = arguments.get(0).evaluate(context);
+            result = arguments.get(0).evaluate(context, isObjectValue);
             checkArguments(result, "source");
         }
         switch (functionName) {
@@ -128,13 +129,13 @@ private ExpressionResult handleSingleArgumentFunctions(EvaluationContext context
             case SynapseConstants.REGISTRY:
                 return handleRegistryAccess(context, result, null);
             case SynapseConstants.EXISTS:
-                return handleExistsCheck(context, arguments.get(0));
+                return handleExistsCheck(context, arguments.get(0), isObjectValue);
             case SynapseConstants.OBJECT:
                 return convertToObject(result);
             case SynapseConstants.ARRAY:
                 return convertToArray(result);
             case SynapseConstants.XPATH:
-                return evaluateXPATHExpression(context, result);
+                return evaluateXPATHExpression(context, result, isObjectValue);
             case SynapseConstants.SECRET:
                 return fetchSecretValue(context, result.asString());
             case SynapseConstants.NOT:
@@ -144,9 +145,9 @@ private ExpressionResult handleSingleArgumentFunctions(EvaluationContext context
         }
     }
 
-    private ExpressionResult handleDoubleArgumentFunctions(EvaluationContext context) {
-        ExpressionResult source = arguments.get(0).evaluate(context);
-        ExpressionResult argument1 = arguments.get(1).evaluate(context);
+    private ExpressionResult handleDoubleArgumentFunctions(EvaluationContext context, boolean isObjectValue) {
+        ExpressionResult source = arguments.get(0).evaluate(context, isObjectValue);
+        ExpressionResult argument1 = arguments.get(1).evaluate(context, isObjectValue);
         checkArguments(source, "source");
         checkArguments(argument1, "argument1");
         switch (functionName) {
@@ -179,10 +180,10 @@ private ExpressionResult handleDoubleArgumentFunctions(EvaluationContext context
         }
     }
 
-    private ExpressionResult handleTripleArgumentFunctions(EvaluationContext context) {
-        ExpressionResult source = arguments.get(0).evaluate(context);
-        ExpressionResult argument1 = arguments.get(1).evaluate(context);
-        ExpressionResult argument2 = arguments.get(2).evaluate(context);
+    private ExpressionResult handleTripleArgumentFunctions(EvaluationContext context, boolean isObjectValue) {
+        ExpressionResult source = arguments.get(0).evaluate(context, isObjectValue);
+        ExpressionResult argument1 = arguments.get(1).evaluate(context, isObjectValue);
+        ExpressionResult argument2 = arguments.get(2).evaluate(context, isObjectValue);
         checkArguments(source, "source");
         checkArguments(argument1, "argument1");
         checkArguments(argument2, "argument2");
@@ -573,9 +574,10 @@ private ExpressionResult handleRegistryAccess(EvaluationContext ctx, ExpressionR
                 + ", propKey: " + propKey.asString());
     }
 
-    private ExpressionResult handleExistsCheck(EvaluationContext context, ExpressionNode expression) {
+    private ExpressionResult handleExistsCheck(EvaluationContext context, ExpressionNode expression,
+                                               boolean isObjectValue) {
         try {
-            ExpressionResult result = expression.evaluate(context);
+            ExpressionResult result = expression.evaluate(context, isObjectValue);
             return result != null ? new ExpressionResult(true) : new ExpressionResult(false);
         } catch (EvaluationException e) {
             // this is the only method we are handling the exceptions
@@ -597,9 +599,15 @@ private ExpressionResult convertToArray(ExpressionResult result) {
         throw new EvaluationException("Argument cannot be converted to a JSON array");
     }
 
-    private ExpressionResult evaluateXPATHExpression(EvaluationContext context, ExpressionResult expression) {
+    private ExpressionResult evaluateXPATHExpression(EvaluationContext context, ExpressionResult expression,
+                                                     boolean isObjectValue) {
         try {
-            return new ExpressionResult(context.evaluateXpathExpression(expression.asString()));
+            Object result = context.evaluateXpathExpression(expression.asString(), isObjectValue);
+            if (isObjectValue) {
+                return new ExpressionResult((List<?>) result);
+            } else {
+                return new ExpressionResult(result.toString());
+            }
         } catch (JaxenException e) {
             throw new EvaluationException("Invalid XPATH expression : " + expression.asString());
         }
diff --git a/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/SignedExpressionNode.java b/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/ast/SignedExpressionNode.java
@@ -36,8 +36,8 @@ public SignedExpressionNode(ExpressionNode expression, boolean signed) {
     }
 
     @Override
-    public ExpressionResult evaluate(EvaluationContext context) {
-        ExpressionResult result = expression.evaluate(context);
+    public ExpressionResult evaluate(EvaluationContext context, boolean isObjectValue) {
+        ExpressionResult result = expression.evaluate(context, isObjectValue);
         if (result == null || result.isNull()) {
             throw new IllegalStateException("Cannot negate a null value");
         }
diff --git a/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/context/EvaluationContext.java b/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/context/EvaluationContext.java
diff --git a/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/visitor/ExpressionVisitor.java b/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/visitor/ExpressionVisitor.java
diff --git a/modules/core/src/main/java/org/apache/synapse/util/xpath/SynapseExpression.java b/modules/core/src/main/java/org/apache/synapse/util/xpath/SynapseExpression.java
diff --git a/modules/core/src/test/java/org/apache/synapse/util/synapse/expression/HeaderAndPropertyAccessTest.java b/modules/core/src/test/java/org/apache/synapse/util/synapse/expression/HeaderAndPropertyAccessTest.java

Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ public List<ExpressionNode> getArguments() {`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`@Override`
`43`		`- public ExpressionResult evaluate(EvaluationContext context) {`
	`43`	`+ public ExpressionResult evaluate(EvaluationContext context, boolean isObjectValue) {`
`44`	`44`	`return null;`
`45`	`45`	`}`
`46`	`46`
Original file line number	Diff line number	Diff line change
`@@ -35,14 +35,14 @@ public ArrayIndexNode(ArgumentListNode arguments, char separator) {`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`@Override`
`38`		`- public ExpressionResult evaluate(EvaluationContext context) {`
	`38`	`+ public ExpressionResult evaluate(EvaluationContext context, boolean isObjectValue) {`
`39`	`39`	`List<String> indexList = new ArrayList<>();`
`40`	`40`	`for (ExpressionNode index : indexArray) {`
`41`	`41`	`if (index == null) {`
`42`	`42`	`indexList.add("");`
`43`	`43`	`continue;`
`44`	`44`	`}`
`45`		`- ExpressionResult result = index.evaluate(context);`
	`45`	`+ ExpressionResult result = index.evaluate(context, isObjectValue);`
`46`	`46`	`if (result != null) {`
`47`	`47`	`indexList.add(result.asString());`
`48`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,13 +38,14 @@ public ConditionalExpressionNode(ExpressionNode condition, ExpressionNode trueEx`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`@Override`
`41`		`- public ExpressionResult evaluate(EvaluationContext context) {`
`42`		`- ExpressionResult conditionResult = condition.evaluate(context);`
	`41`	`+ public ExpressionResult evaluate(EvaluationContext context, boolean isObjectValue) throws EvaluationException {`
	`42`	`+ ExpressionResult conditionResult = condition.evaluate(context, isObjectValue);`
`43`	`43`	`if (conditionResult == null \|\| conditionResult.isNull()) {`
`44`	`44`	`throw new EvaluationException("Condition is null in conditional expression");`
`45`	`45`	`}`
`46`	`46`	`if (conditionResult.isBoolean()) {`
`47`		`- return conditionResult.asBoolean() ? trueExpression.evaluate(context) : falseExpression.evaluate(context);`
	`47`	`+ return conditionResult.asBoolean() ? trueExpression.evaluate(context, isObjectValue)`
	`48`	`+ : falseExpression.evaluate(context, isObjectValue);`
`48`	`49`	`} else {`
`49`	`50`	`throw new EvaluationException("Condition is not a boolean in conditional expression");`
`50`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,5 +25,5 @@`
`25`	`25`	`* Represents a node in the AST.`
`26`	`26`	`*/`
`27`	`27`	`public interface ExpressionNode {`
`28`		`- ExpressionResult evaluate(EvaluationContext context) throws EvaluationException;`
	`28`	`+ ExpressionResult evaluate(EvaluationContext context, boolean isObjectValue) throws EvaluationException;`
`29`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,8 +34,7 @@ public enum Type {`
`34`	`34`	`HEADER,`
`35`	`35`	`PROPERTY,`
`36`	`36`	`CONFIG,`
`37`		`- QUERY_PARAM,`
`38`		`- PATH_PARAM`
	`37`	`+ FUNCTION_PARAM`
`39`	`38`	`}`
`40`	`39`
`41`	`40`	`private final Type type;`
`@@ -56,9 +55,9 @@ public HeadersAndPropertiesAccessNode(ExpressionNode node, String scope) {`
`56`	`55`	`}`
`57`	`56`
`58`	`57`	`@Override`
`59`		`- public ExpressionResult evaluate(EvaluationContext context) {`
	`58`	`+ public ExpressionResult evaluate(EvaluationContext context, boolean isObjectValue) throws EvaluationException {`
`60`	`59`	`if (key != null) {`
`61`		`- String name = key.evaluate(context).asString();`
	`60`	`+ String name = key.evaluate(context, isObjectValue).asString();`
`62`	`61`	`Object value;`
`63`	`62`	`if (Type.HEADER.equals(type)) {`
`64`	`63`	`value = context.getHeader(name);`
`@@ -68,6 +67,8 @@ public ExpressionResult evaluate(EvaluationContext context) {`
`68`	`67`	`} catch (ResolverException e) {`
`69`	`68`	`throw new EvaluationException("The value of the key:[" + name + "] is null");`
`70`	`69`	`}`
	`70`	`+ } else if (Type.FUNCTION_PARAM.equals(type)) {`
	`71`	`+ value = context.getFunctionParam(name);`
`71`	`72`	`} else {`
`72`	`73`	`if (SynapseConstants.URI_PARAM.equals(scope)) {`
`73`	`74`	`value = context.getProperty("uri.var." + name, SynapseConstants.SYNAPSE);`
`@@ -77,7 +78,11 @@ public ExpressionResult evaluate(EvaluationContext context) {`
`77`	`78`	`value = context.getProperty(name, scope);`
`78`	`79`	`}`
`79`	`80`	`}`
`80`		`- return new ExpressionResult(value != null ? value.toString() : null);`
	`81`	`+ if (value != null) {`
	`82`	`+ return new ExpressionResult(value.toString());`
	`83`	`+ } else {`
	`84`	`+ throw new EvaluationException("Could not fetch the value of the key: " + name);`
	`85`	`+ }`
`81`	`86`	`}`
`82`	`87`	`throw new EvaluationException("Key cannot be null when accessing headers or properties");`
`83`	`88`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,8 +36,8 @@ public SignedExpressionNode(ExpressionNode expression, boolean signed) {`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`@Override`
`39`		`- public ExpressionResult evaluate(EvaluationContext context) {`
`40`		`- ExpressionResult result = expression.evaluate(context);`
	`39`	`+ public ExpressionResult evaluate(EvaluationContext context, boolean isObjectValue) {`
	`40`	`+ ExpressionResult result = expression.evaluate(context, isObjectValue);`
`41`	`41`	`if (result == null \|\| result.isNull()) {`
`42`	`42`	`throw new IllegalStateException("Cannot negate a null value");`
`43`	`43`	`}`