Add feature which allows formatting of conductor expression (#204)

* Add initial implemenation

* Create alpha release

* Improve exception messages, add test case

* Improve messages further

* Add ability to interpolate conductor expression formatters

* Update ConductorSharp

Author: boma96

src/ConductorSharp.Client/ConductorSharp.Client.csproj

@@ -6,7 +6,7 @@
 		<Authors>Codaxy</Authors>
 		<Company>Codaxy</Company>
 		<PackageId>ConductorSharp.Client</PackageId>
-		<Version>3.4.1</Version>
+		<Version>3.5.0</Version>
 		<Description>Client library for Netflix Conductor, with some additional quality of life features.</Description>
 		<RepositoryUrl>https://github.com/codaxy/conductor-sharp</RepositoryUrl>
 		<PackageTags>netflix;conductor</PackageTags>

src/ConductorSharp.Engine/ConductorSharp.Engine.csproj

@@ -6,7 +6,7 @@
     <Authors>Codaxy</Authors>
 	<Company>Codaxy</Company>
 	<PackageId>ConductorSharp.Engine</PackageId>
-	<Version>3.4.1</Version>
+	<Version>3.5.0</Version>
     <Description>Client library for Netflix Conductor, with some additional quality of life features.</Description>
 	<RepositoryUrl>https://github.com/codaxy/conductor-sharp</RepositoryUrl>
 	<PackageTags>netflix;conductor</PackageTags>

src/ConductorSharp.Engine/Util/ConductorExpressionFormatterAttribute.cs

@@ -0,0 +1,6 @@
+using System;
+
+namespace ConductorSharp.Engine.Util;
+
+[AttributeUsage(AttributeTargets.Method)]
+public class ConductorExpressionFormatterAttribute : Attribute;

src/ConductorSharp.Engine/Util/ExpressionUtil.cs

@@ -63,9 +63,57 @@ private static object ParseExpression(Expression expression)
             if (IsNameOfExpression(expression))
                 return CompileNameOfExpression((MethodCallExpression)expression);
 
+            if (IsConductorExpressionFormatString(expression))
+                return CompileConductorExpressionFormatString((MethodCallExpression)expression);
+
             return EvaluateExpression(expression);
         }
 
+        private static bool IsConductorExpressionFormatString(Expression expression) =>
+            expression is MethodCallExpression methodExpr
+            && methodExpr.Method.GetCustomAttribute<ConductorExpressionFormatterAttribute>() is not null;
+
+        private static string CompileConductorExpressionFormatString(MethodCallExpression methodExpr)
+        {
+            if (methodExpr.Method.ReturnType != typeof(string))
+                throw new InvalidOperationException($"Format method \"{methodExpr.Method.Name}\" must return string");
+
+            var args = new List<object>();
+
+            foreach (var (argExpr, paramInfo) in methodExpr.Arguments.Zip(methodExpr.Method.GetParameters(), (expr, paramInfo) => (expr, paramInfo)))
+            {
+                if (paramInfo.GetCustomAttribute<FormatterParameterAttribute>() is not null)
+                {
+                    if (argExpr.Type != typeof(string))
+                        throw new InvalidOperationException(
+                            $"Parameter \"{paramInfo.Name}\" marked with {nameof(FormatterParameterAttribute)} of format method \"{methodExpr.Method.Name}\" is not a string"
+                        );
+
+                    if (!ShouldCompileToJsonPathExpression(argExpr))
+                        throw new InvalidOperationException(
+                            $"Argument {argExpr} corresponding to parameter \"{paramInfo.Name}\" marked with {nameof(FormatterParameterAttribute)} of format method \"{methodExpr.Method.Name}\" can not be compiled to expression string"
+                        );
+
+                    args.Add(CreateExpressionString(argExpr));
+                }
+                else if (!IsEvaluatable(argExpr))
+                {
+                    throw new InvalidOperationException(
+                        $"Argument {argExpr} corresponding to parameter \"{paramInfo.Name}\" of format method \"{methodExpr.Method.Name}\" can not be evaluated"
+                    );
+                }
+                else
+                    args.Add(EvaluateExpression(argExpr));
+            }
+
+            if (methodExpr.Object is not null && !IsEvaluatable(methodExpr.Object))
+                throw new InvalidOperationException(
+                    $"Format method \"{methodExpr.Method.Name}\" is being called on non evaluatable expression {methodExpr.Object}"
+                );
+
+            return (string)methodExpr.Method.Invoke(methodExpr.Object is not null ? EvaluateExpression(methodExpr.Object) : null, args.ToArray());
+        }
+
         private static bool IsStringInterpolation(Expression expression) =>
             expression is MethodCallExpression { Method.Name: nameof(string.Format) } methodExpression
             && methodExpression.Method.DeclaringType == typeof(string);
@@ -271,6 +319,9 @@ private static object CompileInterpolatedStringArgument(Expression expr)
                 return ParseConstantExpression(cex);
             if (expr is UnaryExpression { NodeType: ExpressionType.Convert } uex)
                 return CompileInterpolatedStringArgument(uex.Operand);
+            if (IsConductorExpressionFormatString(expr))
+                return CompileConductorExpressionFormatString((MethodCallExpression)expr);
+
             return EvaluateExpression(expr);
         }
 

src/ConductorSharp.Engine/Util/FormatterParameterAttribute.cs

@@ -0,0 +1,6 @@
+using System;
+
+namespace ConductorSharp.Engine.Util;
+
+[AttributeUsage(AttributeTargets.Parameter)]
+public class FormatterParameterAttribute : Attribute;

src/ConductorSharp.KafkaCancellationNotifier/ConductorSharp.KafkaCancellationNotifier.csproj

@@ -4,7 +4,7 @@
     <TargetFramework>net6.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
-    <Version>3.4.1</Version>
+    <Version>3.5.0</Version>
     <Authors>Codaxy</Authors>
     <Company>Codaxy</Company>
   </PropertyGroup>

src/ConductorSharp.Patterns/ConductorSharp.Patterns.csproj

@@ -7,7 +7,7 @@
     <GeneratePackageOnBuild>False</GeneratePackageOnBuild>
     <Authors>Codaxy</Authors>
     <Company>Codaxy</Company>
-    <Version>3.4.1</Version>
+    <Version>3.5.0</Version>
   </PropertyGroup>
 
 	<ItemGroup>

test/ConductorSharp.Engine.Tests/ConductorSharp.Engine.Tests.csproj

@@ -20,6 +20,7 @@
     <None Remove="Samples\Workflows\DynamicTask.json" />
     <None Remove="Samples\Workflows\EvaluateExpressionWorkflow.json" />
     <None Remove="Samples\Workflows\EventTaskWorkflow.json" />
+    <None Remove="Samples\Workflows\FormatterWorkflow.json" />
     <None Remove="Samples\Workflows\HumanTaskWorkflow.json" />
     <None Remove="Samples\Workflows\IndexerWorkflow.json" />
     <None Remove="Samples\Workflows\ListInitializationWorkflow.json" />
@@ -41,6 +42,7 @@
 
   <ItemGroup>
     <EmbeddedResource Include="Samples\Workflows\DictionaryInitializationWorkflow.json" />
+    <EmbeddedResource Include="Samples\Workflows\FormatterWorkflow.json" />
     <EmbeddedResource Include="Samples\Workflows\HumanTaskWorkflow.json" />
     <EmbeddedResource Include="Samples\Workflows\ListInitializationWorkflow.json" />
     <EmbeddedResource Include="Samples\Workflows\EvaluateExpressionWorkflow.json" />

test/ConductorSharp.Engine.Tests/Integration/WorkflowBuilderTests.cs

@@ -239,11 +239,17 @@ public void BuilderReturnsCorrectDefinitionEvaluateExpressionWorkflow()
         }
 
         [Fact]
-        public void BuilderReturnsCorrectDefinitionNonEvaluatableWorkflow()
+        public void BuilderThrowsNonEvaluatableWorkflowExcepion()
         {
             Assert.Throws<NonEvaluatableExpressionException>(GetDefinitionFromWorkflow<NonEvaluatableWorkflow>);
         }
 
+        [Fact]
+        public void BuilderThrowsInvalidOperationExceptionForInvalidFormatterArgument()
+        {
+            Assert.Throws<InvalidOperationException>(GetDefinitionFromWorkflow<InvalidFormatterArgumentWorkflow>);
+        }
+
         [Fact]
         public void BuilderReturnsCorrectDefinitionWorkflowMetadataWorkflow()
         {
@@ -271,6 +277,15 @@ public void BuilderReturnsCorrectDefinitionDictionaryInitializationWorkflow()
             Assert.Equal(expectedDefinition, definition);
         }
 
+        [Fact]
+        public void BuilderReturnsCorrectDefinitionFormatterWorkflow()
+        {
+            var definition = GetDefinitionFromWorkflow<FormatterWorkflow>();
+            var expectedDefinition = EmbeddedFileHelper.GetLinesFromEmbeddedFile("~/Samples/Workflows/FormatterWorkflow.json");
+
+            Assert.Equal(expectedDefinition, definition);
+        }
+
         private static string GetDefinitionFromWorkflow<TWorkflow>()
             where TWorkflow : IConfigurableWorkflow
         {

test/ConductorSharp.Engine.Tests/Samples/Workflows/FormatterWorkflow.cs

@@ -0,0 +1,43 @@
+namespace ConductorSharp.Engine.Tests.Samples.Workflows;
+
+public class FormatterWorkflowInput : WorkflowInput<FormatterWorkflowOutput>
+{
+    public string FirstName { get; set; }
+    public string LastName { get; set; }
+}
+
+public class FormatterWorkflowOutput : WorkflowOutput { }
+
+public class FormatterWorkflow : Workflow<FormatterWorkflow, FormatterWorkflowInput, FormatterWorkflowOutput>
+{
+    public class Library
+    {
+        public static Library Singleton { get; } = new();
+
+        [ConductorExpressionFormatter]
+        public string PrepareEmail([FormatterParameter] string firstName, [FormatterParameter] string lastName) =>
+            $"{firstName}.{lastName}@example.com";
+
+        [ConductorExpressionFormatter]
+        public static string FormatName([FormatterParameter] string firstName, [FormatterParameter] string lastName, string prefix) =>
+            $"{prefix} {firstName} {lastName}";
+    }
+
+    public EmailPrepareV1 EmailPrepare { get; set; }
+
+    public FormatterWorkflow(WorkflowDefinitionBuilder<FormatterWorkflow, FormatterWorkflowInput, FormatterWorkflowOutput> builder)
+        : base(builder) { }
+
+    public override void BuildDefinition()
+    {
+        _builder.AddTask(
+            wf => wf.EmailPrepare,
+            wf =>
+                new()
+                {
+                    Address = Library.Singleton.PrepareEmail(wf.Input.FirstName, wf.Input.LastName),
+                    Name = Library.FormatName(wf.Input.FirstName, wf.Input.LastName, "Mr")
+                }
+        );
+    }
+}