Ignore nulls in decision tasks

src/ConductorSharp.Client/ConductorConstants.cs

@@ -15,5 +15,6 @@ public static class ConductorConstants
                 MetadataPropertyHandling = MetadataPropertyHandling.ReadAhead,
                 TypeNameHandling = TypeNameHandling.Auto
             };
+        public static JsonSerializer DefinitionsSerializer { get; } = new() { NullValueHandling = NullValueHandling.Ignore };
     }
 }

src/ConductorSharp.Engine/Builders/DecisionTaskBuilder.cs

@@ -1,161 +1,164 @@
-using ConductorSharp.Client.Model.Common;
-using ConductorSharp.Engine.Interface;
-using ConductorSharp.Engine.Model;
-using MediatR;
-using Newtonsoft.Json.Linq;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-
-namespace ConductorSharp.Engine.Builders
-{
-    public static class DecisionTaskExtensions
-    {
-        public static ITaskOptionsBuilder AddTask<TWorkflow>(
-            this WorkflowDefinitionBuilder<TWorkflow> builder,
-            Expression<Func<TWorkflow, DecisionTaskModel>> taskSelector,
-            Expression<Func<TWorkflow, DecisionTaskInput>> expression,
-            params (string, Action<DecisionTaskBuilder<TWorkflow>>)[] caseActions
-        ) where TWorkflow : ITypedWorkflow
-        {
-            var taskBbuilder = new DecisionTaskBuilder<TWorkflow>(taskSelector.Body, expression.Body);
-
-            foreach (var funcase in caseActions)
-            {
-                taskBbuilder.AddCase(funcase.Item1);
-                funcase.Item2.Invoke(taskBbuilder);
-            }
-
-            builder.Context.TaskBuilders.Add(taskBbuilder);
-            return taskBbuilder;
-        }
-    }
-
-    public class DecisionTaskBuilder<TWorkflow> : BaseTaskBuilder<DecisionTaskInput, NoOutput> where TWorkflow : ITypedWorkflow
-    {
-        private Dictionary<string, List<ITaskBuilder>> _caseDictionary = new();
-
-        private string _currentCaseName;
-
-        public DecisionTaskBuilder(Expression taskExpression, Expression inputExpression) : base(taskExpression, inputExpression) { }
-
-        public DecisionTaskBuilder<TWorkflow> AddCase(string caseName)
-        {
-            _currentCaseName = caseName;
-
-            if (!_caseDictionary.ContainsKey(_currentCaseName))
-                _caseDictionary.Add(caseName, new List<ITaskBuilder>());
-
-            return this;
-        }
-
-        public DecisionTaskBuilder<TWorkflow> WithTask<F, G>(
-            Expression<Func<TWorkflow, SubWorkflowTaskModel<F, G>>> referrence,
-            Expression<Func<TWorkflow, F>> input
-        ) where F : IRequest<G>
-        {
-            var builder = new SubWorkflowTaskBuilder<F, G>(referrence.Body, input.Body);
-            _caseDictionary[_currentCaseName].Add(builder);
-
-            return this;
-        }
-
-        public DecisionTaskBuilder<TWorkflow> WithTask<F, G>(
-            Expression<Func<TWorkflow, LambdaTaskModel<F, G>>> taskSelector,
-            Expression<Func<TWorkflow, F>> expression,
-            string script
-        ) where F : IRequest<G>
-        {
-            var builder = new LambdaTaskBuilder<F, G>(script, taskSelector.Body, expression.Body);
-            _caseDictionary[_currentCaseName].Add(builder);
-
-            return this;
-        }
-
-        public DecisionTaskBuilder<TWorkflow> WithTask(
-            Expression<Func<TWorkflow, DynamicForkJoinTaskModel>> taskSelector,
-            Expression<Func<TWorkflow, DynamicForkJoinInput>> expression
-        )
-        {
-            var builder = new DynamicForkJoinTaskBuilder(taskSelector.Body, expression.Body);
-            _caseDictionary[_currentCaseName].Add(builder);
-
-            return this;
-        }
-
-        public DecisionTaskBuilder<TWorkflow> WithTask<F, G>(
-            Expression<Func<TWorkflow, SimpleTaskModel<F, G>>> taskSelector,
-            Expression<Func<TWorkflow, F>> expression,
-            AdditionalTaskParameters additionalParameters = null
-        ) where F : IRequest<G>
-        {
-            var builder = new SimpleTaskBuilder<F, G>(taskSelector.Body, expression.Body, additionalParameters);
-            _caseDictionary[_currentCaseName].Add(builder);
-
-            return this;
-        }
-
-        public DecisionTaskBuilder<TWorkflow> WithTask(
-            Expression<Func<TWorkflow, TerminateTaskModel>> taskSelector,
-            Expression<Func<TWorkflow, TerminateTaskInput>> expression
-        )
-        {
-            var builder = new TerminateTaskBuilder(taskSelector.Body, expression.Body);
-            _caseDictionary[_currentCaseName].Add(builder);
-
-            return this;
-        }
-
-        public DecisionTaskBuilder<TWorkflow> WithTask<F, G>(
-            Expression<Func<TWorkflow, DynamicTaskModel<F, G>>> taskSelector,
-            Expression<Func<TWorkflow, DynamicTaskInput<F, G>>> expression
-        ) where F : IRequest<G>
-        {
-            var builder = new DynamicTaskBuilder<F, G>(taskSelector.Body, expression.Body);
-            _caseDictionary[_currentCaseName].Add(builder);
-
-            return this;
-        }
-
-        public DecisionTaskBuilder<TWorkflow> WithTask(
-            Expression<Func<TWorkflow, DecisionTaskModel>> taskSelector,
-            Expression<Func<TWorkflow, DecisionTaskInput>> expression,
-            params (string, Action<DecisionTaskBuilder<TWorkflow>>)[] caseActions
-        )
-        {
-            var builder = new DecisionTaskBuilder<TWorkflow>(taskSelector.Body, expression.Body);
-
-            foreach (var funcase in caseActions)
-            {
-                builder.AddCase(funcase.Item1);
-                funcase.Item2.Invoke(builder);
-            }
-
-            _caseDictionary[_currentCaseName].Add(builder);
-
-            return this;
-        }
-
-        public override WorkflowDefinition.Task[] Build()
-        {
-            var decisionTaskName = $"DECISION_{_taskRefferenceName}";
-
-            return new WorkflowDefinition.Task[]
-            {
-                new WorkflowDefinition.Task
-                {
-                    Name = decisionTaskName,
-                    TaskReferenceName = _taskRefferenceName,
-                    InputParameters = _inputParameters,
-                    Type = "DECISION",
-                    CaseValueParam = "case_value_param",
-                    DecisionCases = new Newtonsoft.Json.Linq.JObject
-                    {
-                        _caseDictionary.Select(a => new JProperty(a.Key, JArray.FromObject(a.Value.SelectMany(a => a.Build()))))
-                    }
-                }
-            };
-        }
-    }
-}
+using ConductorSharp.Client;
+using ConductorSharp.Client.Model.Common;
+using ConductorSharp.Engine.Interface;
+using ConductorSharp.Engine.Model;
+using MediatR;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+
+namespace ConductorSharp.Engine.Builders
+{
+    public static class DecisionTaskExtensions
+    {
+        public static ITaskOptionsBuilder AddTask<TWorkflow>(
+            this WorkflowDefinitionBuilder<TWorkflow> builder,
+            Expression<Func<TWorkflow, DecisionTaskModel>> taskSelector,
+            Expression<Func<TWorkflow, DecisionTaskInput>> expression,
+            params (string, Action<DecisionTaskBuilder<TWorkflow>>)[] caseActions
+        ) where TWorkflow : ITypedWorkflow
+        {
+            var taskBbuilder = new DecisionTaskBuilder<TWorkflow>(taskSelector.Body, expression.Body);
+
+            foreach (var funcase in caseActions)
+            {
+                taskBbuilder.AddCase(funcase.Item1);
+                funcase.Item2.Invoke(taskBbuilder);
+            }
+
+            builder.Context.TaskBuilders.Add(taskBbuilder);
+            return taskBbuilder;
+        }
+    }
+
+    public class DecisionTaskBuilder<TWorkflow> : BaseTaskBuilder<DecisionTaskInput, NoOutput> where TWorkflow : ITypedWorkflow
+    {
+        private Dictionary<string, List<ITaskBuilder>> _caseDictionary = new();
+
+        private string _currentCaseName;
+
+        public DecisionTaskBuilder(Expression taskExpression, Expression inputExpression) : base(taskExpression, inputExpression) { }
+
+        public DecisionTaskBuilder<TWorkflow> AddCase(string caseName)
+        {
+            _currentCaseName = caseName;
+
+            if (!_caseDictionary.ContainsKey(_currentCaseName))
+                _caseDictionary.Add(caseName, new List<ITaskBuilder>());
+
+            return this;
+        }
+
+        public DecisionTaskBuilder<TWorkflow> WithTask<F, G>(
+            Expression<Func<TWorkflow, SubWorkflowTaskModel<F, G>>> referrence,
+            Expression<Func<TWorkflow, F>> input
+        ) where F : IRequest<G>
+        {
+            var builder = new SubWorkflowTaskBuilder<F, G>(referrence.Body, input.Body);
+            _caseDictionary[_currentCaseName].Add(builder);
+
+            return this;
+        }
+
+        public DecisionTaskBuilder<TWorkflow> WithTask<F, G>(
+            Expression<Func<TWorkflow, LambdaTaskModel<F, G>>> taskSelector,
+            Expression<Func<TWorkflow, F>> expression,
+            string script
+        ) where F : IRequest<G>
+        {
+            var builder = new LambdaTaskBuilder<F, G>(script, taskSelector.Body, expression.Body);
+            _caseDictionary[_currentCaseName].Add(builder);
+
+            return this;
+        }
+
+        public DecisionTaskBuilder<TWorkflow> WithTask(
+            Expression<Func<TWorkflow, DynamicForkJoinTaskModel>> taskSelector,
+            Expression<Func<TWorkflow, DynamicForkJoinInput>> expression
+        )
+        {
+            var builder = new DynamicForkJoinTaskBuilder(taskSelector.Body, expression.Body);
+            _caseDictionary[_currentCaseName].Add(builder);
+
+            return this;
+        }
+
+        public DecisionTaskBuilder<TWorkflow> WithTask<F, G>(
+            Expression<Func<TWorkflow, SimpleTaskModel<F, G>>> taskSelector,
+            Expression<Func<TWorkflow, F>> expression,
+            AdditionalTaskParameters additionalParameters = null
+        ) where F : IRequest<G>
+        {
+            var builder = new SimpleTaskBuilder<F, G>(taskSelector.Body, expression.Body, additionalParameters);
+            _caseDictionary[_currentCaseName].Add(builder);
+
+            return this;
+        }
+
+        public DecisionTaskBuilder<TWorkflow> WithTask(
+            Expression<Func<TWorkflow, TerminateTaskModel>> taskSelector,
+            Expression<Func<TWorkflow, TerminateTaskInput>> expression
+        )
+        {
+            var builder = new TerminateTaskBuilder(taskSelector.Body, expression.Body);
+            _caseDictionary[_currentCaseName].Add(builder);
+
+            return this;
+        }
+
+        public DecisionTaskBuilder<TWorkflow> WithTask<F, G>(
+            Expression<Func<TWorkflow, DynamicTaskModel<F, G>>> taskSelector,
+            Expression<Func<TWorkflow, DynamicTaskInput<F, G>>> expression
+        ) where F : IRequest<G>
+        {
+            var builder = new DynamicTaskBuilder<F, G>(taskSelector.Body, expression.Body);
+            _caseDictionary[_currentCaseName].Add(builder);
+
+            return this;
+        }
+
+        public DecisionTaskBuilder<TWorkflow> WithTask(
+            Expression<Func<TWorkflow, DecisionTaskModel>> taskSelector,
+            Expression<Func<TWorkflow, DecisionTaskInput>> expression,
+            params (string, Action<DecisionTaskBuilder<TWorkflow>>)[] caseActions
+        )
+        {
+            var builder = new DecisionTaskBuilder<TWorkflow>(taskSelector.Body, expression.Body);
+
+            foreach (var funcase in caseActions)
+            {
+                builder.AddCase(funcase.Item1);
+                funcase.Item2.Invoke(builder);
+            }
+
+            _caseDictionary[_currentCaseName].Add(builder);
+
+            return this;
+        }
+
+        public override WorkflowDefinition.Task[] Build()
+        {
+            var decisionTaskName = $"DECISION_{_taskRefferenceName}";
+
+            return new WorkflowDefinition.Task[]
+            {
+                new WorkflowDefinition.Task
+                {
+                    Name = decisionTaskName,
+                    TaskReferenceName = _taskRefferenceName,
+                    InputParameters = _inputParameters,
+                    Type = "DECISION",
+                    CaseValueParam = "case_value_param",
+                    DecisionCases = new Newtonsoft.Json.Linq.JObject
+                    {
+                        _caseDictionary.Select(
+                            a => new JProperty(a.Key, JArray.FromObject(a.Value.SelectMany(a => a.Build()), ConductorConstants.DefinitionsSerializer))
+                        )
+                    }
+                }
+            };
+        }
+    }
+}

src/ConductorSharp.Engine/Builders/SwitchTaskBuilder.cs

@@ -1,4 +1,5 @@
-using ConductorSharp.Client.Model.Common;
+using ConductorSharp.Client;
+using ConductorSharp.Client.Model.Common;
 using ConductorSharp.Engine.Interface;
 using ConductorSharp.Engine.Model;
 using MediatR;
@@ -152,7 +153,9 @@ public override WorkflowDefinition.Task[] Build()
                     EvaluatorType = "value-param",
                     DecisionCases = new Newtonsoft.Json.Linq.JObject
                     {
-                        _caseDictionary.Select(a => new JProperty(a.Key, JArray.FromObject(a.Value.SelectMany(b => b.Build()))))
+                        _caseDictionary.Select(
+                            a => new JProperty(a.Key, JArray.FromObject(a.Value.SelectMany(b => b.Build()), ConductorConstants.DefinitionsSerializer))
+                        )
                     }
                 }
             };

test/ConductorSharp.Engine.Tests/Samples/Workflows/ConditionallySendCustomerNotificationOutput.json

@@ -26,42 +26,21 @@
       "decisionCases": {
         "YES": [
           {
-            "queryExpression": null,
             "name": "NOTIFICATION_send_to_customer",
             "taskReferenceName": "send_notification_subworkflow",
             "description": "{\"description\":null}",
             "inputParameters": {
               "customer_id": "${workflow.input.customer_id}"
             },
             "type": "SUB_WORKFLOW",
-            "dynamicTaskNameParam": null,
-            "caseValueParam": null,
-            "caseExpression": null,
-            "expression": null,
-            "evaluatorType": null,
-            "scriptExpression": null,
-            "decisionCases": null,
-            "dynamicForkJoinTasksParam": null,
-            "dynamicForkTasksParam": null,
-            "dynamicForkTasksInputParamName": null,
-            "defaultCase": null,
-            "forkTasks": null,
             "startDelay": 0,
             "subWorkflowParam": {
               "name": "NOTIFICATION_send_to_customer",
-              "version": 1,
-              "taskToDomain": null,
-              "workflowDefinition": null
+              "version": 1
             },
-            "joinOn": null,
-            "sink": null,
             "optional": false,
-            "taskDefinition": null,
             "rateLimited": false,
-            "defaultExclusiveJoinTask": null,
-            "asyncComplete": false,
-            "loopCondition": null,
-            "loopOver": null
+            "asyncComplete": false
           }
         ]
       },