Make script argument immutable based on config

Author: Rajesh Jinaga

src/Simpleflow/CodeGenerator/ArgumentImmutabilityCheck.cs

@@ -0,0 +1,39 @@
+// Copyright (c) navtech.io. All rights reserved. 
+// See License in the project root for license information.
+
+namespace Simpleflow.CodeGenerator
+{
+    internal static class ArgumentImmutabilityCheck
+    {
+        public static bool CheckForSameReference(object scriptArgument, object variable)
+        {
+            if (scriptArgument == null || variable == null )
+            {
+                return false;
+            }
+
+            if (object.ReferenceEquals(scriptArgument, variable))
+            {
+                return true;
+            }
+
+            if (scriptArgument != null)
+            {
+                // Deep dive for checking reference
+                foreach (var prop in scriptArgument.GetType().GetProperties())
+                {
+                    if (prop.PropertyType.IsClass && prop.PropertyType != typeof(string))
+                    {
+                        var value = prop.GetValue(scriptArgument);
+                        if (value != null)
+                        {
+                            return CheckForSameReference(prop.GetValue(scriptArgument), variable);
+                        }
+                    }
+                }
+            }
+
+            return false;
+        }
+    }
+}

src/Simpleflow/CodeGenerator/SimpleflowCodeVisitor.VisitEmitters.cs

@@ -43,7 +43,7 @@ public override Expression VisitOutputStmt(SimpleflowParser.OutputStmtContext co
             var name = context.objectIdentifier().GetText();
 
             Expression callExpr = Expression.Call(
-                instance: Expression.Property(Output, nameof(FlowOutput.Output)),
+                instance: Expression.Property(OutputParam, nameof(FlowOutput.Output)),
 
                 // ReSharper disable once AssignNullToNotNullAttribute
                 method: typeof(Dictionary<string, object>).GetMethod(
@@ -70,7 +70,7 @@ private Expression CallListAddMethod(Expression message, string propertyName)
         {
 
             Expression callExpr = Expression.Call(
-                Expression.Property(Output, propertyName),
+                Expression.Property(OutputParam, propertyName),
                 // ReSharper disable once AssignNullToNotNullAttribute
                 typeof(List<string>).GetMethod(nameof(List<string>.Add), new Type[] { typeof(string) }),
                 message

src/Simpleflow/CodeGenerator/SimpleflowCodeVisitor.VistitLetSet.cs

@@ -259,7 +259,6 @@ private Expression GetLetVariableExpression(SimpleflowParser.ExpressionContext c
 
         private Expression VisitPartialSet(SimpleflowParser.SetStmtContext context, Expression variable)
         {
-            // variable.Left.Type
             var pairs = context.expression().jsonObj().pair();
             List<Expression> propExpressions = new List<Expression>();
 
@@ -269,8 +268,24 @@ private Expression VisitPartialSet(SimpleflowParser.SetStmtContext context, Expr
                                  (propInfo, valueExp) =>
                                         propExpressions.Add(Expression.Assign(Expression.Property(variable, propInfo), valueExp)));
 
-            // context.expression
-            return Expression.Block(propExpressions);
+            /*
+             *  Check for script argument immutability, exception case: if a function change property of script arg, 
+             *  simppleflow does not control.
+             */
+            var referenceProperties = new List<Expression>();
+            var checkForSameReference = Expression.Call(null,
+                                                    typeof(ArgumentImmutabilityCheck).GetMethod(nameof(ArgumentImmutabilityCheck.CheckForSameReference)),
+                                                    arg0: InputParam,
+                                                    arg1: variable);
+
+            return
+            Expression.IfThenElse(
+                    Expression.Or(
+                           Expression.IsTrue(Expression.Property(ScriptHelperContextParam, nameof(ScriptHelperContext.IsArgumentMutable))),
+                           Expression.IsFalse(checkForSameReference)),
+                    Expression.Block(propExpressions),
+                    Expression.Throw(Expression.New(typeof(ArgumentImmutableExeception))) 
+                );
         }
     }
 }

src/Simpleflow/CodeGenerator/SimpleflowCodeVisitor.cs

@@ -23,9 +23,9 @@ internal partial class SimpleflowCodeVisitor<TArg> : SimpleflowParserBaseVisitor
         protected readonly List<ParameterExpression> Variables;  // program variables
         protected readonly List<SmartJsonObjectParameterExpression> SmartJsonVariables;  // program variables
 
-        protected readonly ParameterExpression Input;  // script main function parameter 1
-        protected readonly ParameterExpression Output; // script main function parameter 2
-        protected readonly ParameterExpression ScriptHelperContext; //script main function  parameter 3
+        protected readonly ParameterExpression InputParam;  // script main function parameter 1
+        protected readonly ParameterExpression OutputParam; // script main function parameter 2
+        protected readonly ParameterExpression ScriptHelperContextParam; //script main function  parameter 3
 
         protected readonly ParserEventPublisher EventPublisher;
 
@@ -39,10 +39,10 @@ public SimpleflowCodeVisitor(IFunctionRegister functionRegister, ParserEventPubl
             SmartJsonVariables = new List<SmartJsonObjectParameterExpression>();
 
             /* Initialize Function parameters */
-            Input = Expression.Parameter(typeof(TArg));
-            Output = Expression.Parameter(typeof(FlowOutput));
+            InputParam = Expression.Parameter(typeof(TArg));
+            OutputParam = Expression.Parameter(typeof(FlowOutput));
             // use context parameter name in order to access in script
-            ScriptHelperContext = Expression.Parameter(typeof(ScriptHelperContext), "context");
+            ScriptHelperContextParam = Expression.Parameter(typeof(ScriptHelperContext), "context");
 
 
             /* A label expression of the void type that is the target for Expression.Return(). */
@@ -72,7 +72,7 @@ public override Expression VisitProgram(SimpleflowParser.ProgramContext context)
             Expression<Action<TArg, FlowOutput, ScriptHelperContext>> program =
                 Expression.Lambda<Action<TArg /*input-context*/, FlowOutput, ScriptHelperContext>>(
                     body,
-                    new ParameterExpression[] { Input, Output, ScriptHelperContext }
+                    new ParameterExpression[] { InputParam, OutputParam, ScriptHelperContextParam }
                 );
 
             return program;
@@ -238,11 +238,11 @@ private List<Expression> CreateDefaultVariablesAndAssign()
             var argVar = Expression.Variable(typeof(TArg), "arg");
 
             Variables.Add(argVar);               // arg
-            Variables.Add(ScriptHelperContext);  // script
+            Variables.Add(ScriptHelperContextParam);  // script
 
             return new List<Expression>()
             {
-                Expression.Assign(argVar, Input)
+                Expression.Assign(argVar, InputParam)
             };
         }
 

src/Simpleflow/Exceptions/ArgumentImmutableExeception.cs

@@ -0,0 +1,23 @@
+// Copyright (c) navtech.io. All rights reserved. 
+// See License in the project root for license information.
+
+using System;
+
+namespace Simpleflow.Exceptions
+{
+    /// <summary>
+    /// Represents base exception for all Simpleflow exceptions
+    /// </summary>
+    public class ArgumentImmutableExeception : Exception
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SimpleflowException"/> class with
+        /// a specified variable name.
+        /// </summary>
+        /// <param name="message">The message that describes the error.</param>
+        public ArgumentImmutableExeception(): base($"Script argument cannot be mutable in this context. Set {nameof(FlowOptions.AllowArgumentToMutate)} options to true in order to modify argument")
+        {
+
+        }
+    }
+}

src/Simpleflow/FlowOptions.cs

@@ -10,7 +10,7 @@ public class FlowOptions : IOptions
         /// <summary>
         /// Gets or sets AllowArgumentToMutate
         /// </summary>
-        // public bool AllowArgumentToMutate { get; set; }  // Implement in next release
+        public bool AllowArgumentToMutate { get; set; } 
 
         /// <summary>
         /// Gets or sets AllowFunctions

src/Simpleflow/IOptions.cs

@@ -11,7 +11,7 @@ public interface IOptions
         /// <summary>
         /// Gets or sets AllowArgumentToMutate
         /// </summary>
-        //bool AllowArgumentToMutate { get;  } // Implement in next release Check CacheService related impl
+        bool AllowArgumentToMutate { get;  }
 
         /// <summary>
         /// Gets or sets AllowFunctions

src/Simpleflow/ScriptHelperContext.cs

@@ -12,13 +12,14 @@ public sealed class ScriptHelperContext
 
         private ScriptHelperContext() { }
 
-        internal ScriptHelperContext(FlowOutput flowOutput, CancellationToken token)
+        internal ScriptHelperContext(FlowOutput flowOutput, bool isArgumentMutable, CancellationToken token)
         {
             _flowOutput = flowOutput;
             _token = token;
+            IsArgumentMutable = isArgumentMutable;
         }
 
-
+        public bool IsArgumentMutable { get; }
         public bool HasErrors => _flowOutput.Errors.Count > 0;
         public bool HasMessages => _flowOutput.Messages.Count > 0;
         public bool HasOutputs => _flowOutput.Output.Count > 0;

src/Simpleflow/Services/CompilerService.cs

@@ -15,6 +15,7 @@ namespace Simpleflow.Services
     public class CompilerService : IFlowPipelineService
     {
         private readonly IFunctionRegister _functionRegister;
+        private readonly IOptions _options;
 
         /// <summary>
         /// 
@@ -24,6 +25,7 @@ public class CompilerService : IFlowPipelineService
         public CompilerService(IFunctionRegister functionRegister, IOptions options = null)
         {
             _functionRegister = functionRegister ?? throw new ArgumentNullException(nameof(functionRegister));
+            _options = options;
         }
 
         /// <inheritdoc />
@@ -58,25 +60,27 @@ So here we don't need to run again  */
             next?.Invoke(context);
         }
 
-        private static void CheckFunctionExecutionPermissions<TArg>(FlowContext<TArg> context, ParserEventPublisher eventPublisher)
+        private void CheckFunctionExecutionPermissions<TArg>(FlowContext<TArg> context, ParserEventPublisher eventPublisher)
         {
             eventPublisher.OnVisit = (type, data) =>
             {
+                var options = context.Options ?? _options;
+
                 if (type == EventType.VisitFunctionOnAvail
-                    && context.Options?.DenyFunctions != null)
+                    && options?.DenyFunctions != null)
                 {
                     var functionName = data.ToString();
-                    if (context.Options.DenyFunctions.Contains(functionName, StringComparer.OrdinalIgnoreCase))
+                    if (options.DenyFunctions.Contains(functionName, StringComparer.OrdinalIgnoreCase))
                     {
                         throw new AccessDeniedException($"Function '{functionName}' cannot be allowed to run in this context.");
                     }
                 }
 
                 if (type == EventType.VisitFunctionOnAvail
-                    && context.Options?.AllowFunctions != null)
+                    && options?.AllowFunctions != null)
                 {
                     var functionName = data.ToString();
-                    if (!context.Options.AllowFunctions.Contains(functionName, StringComparer.OrdinalIgnoreCase))
+                    if (!options.AllowFunctions.Contains(functionName, StringComparer.OrdinalIgnoreCase))
                     {
                         throw new AccessDeniedException($"Function '{functionName}' cannot be allowed to run in this context.");
                     }

src/Simpleflow/Services/ExecutionService.cs

@@ -1,21 +1,43 @@
 // Copyright (c) navtech.io. All rights reserved.
 // See License in the project root for license information.
 
+using System;
+
 namespace Simpleflow.Services
 {
     /// <summary>
     /// A service to run the machine code instructions
     /// </summary>
     public class ExecutionService : IFlowPipelineService
     {
+        readonly IOptions _options;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public ExecutionService()
+        {
+            
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="options"></param>
+        public ExecutionService(IOptions options)
+        {
+            _options = options ?? throw new ArgumentNullException(nameof(options));
+        }
+
         /// <inheritdoc />
         public void Run<TArg>(FlowContext<TArg> context, NextPipelineService<TArg> next)
         {
             // Add trace for debugging
             context.Trace?.CreateNewTracePoint(nameof(ExecutionService));
 
-            var scriptHelperContext = new ScriptHelperContext(context.Output, 
-                                                              context.Options?.CancellationToken ?? default);
+            var scriptHelperContext = new ScriptHelperContext(context.Output,
+                                                             (context.Options?.AllowArgumentToMutate ?? _options?.AllowArgumentToMutate) ?? true,
+                                                             context.Options?.CancellationToken ?? default);
 
             context.Internals.CompiledScript?.Invoke(context.Argument, context.Output, scriptHelperContext);