Implement Dynamic Expression Evaluation for Log Persistence Mode (#6159)

* Add log persistence configuration and strategy evaluation

Introduced `LogPersistenceConfiguration` to support dynamic strategy and expression-based log persistence evaluations. Updated `Default default values.

* Add LogPersistenceConfiguration and enum support

Introduced LogPersistenceConfiguration class and LogPersistenceEvaluationMode enum in both Elsa.Api.Client and Elsa.Workflows.Runtime. Updated JavaScript services to handle enums correctly and register LogPersistenceMode.

* Rename log persistence key for consistency

Updated the log persistence key from `LogPersistenceStrategyKey` to `LogPersistenceConfigKey` to maintain consistency across the codebase. This change ensures that property access aligns with the updated naming conventions used in the application's configuration.

* Reuse JSON serializer options

* Update log persistence config structure in comments

This commit revises the JSON example in code comments to reflect the updated structure of the log persistence configuration. The changes include updated evaluation modes and strategy types for default, inputs, and outputs sections. These modifications aim to enhance clarity and provide accurate documentation of the expected configuration format.

src/clients/Elsa.Api.Client/Shared/Enums/LogPersistenceEvaluationMode.cs

@@ -0,0 +1,7 @@
+namespace Elsa.Api.Client.Shared.Enums;
+
+public enum LogPersistenceEvaluationMode
+{
+    Strategy,
+    Expression
+}

src/clients/Elsa.Api.Client/Shared/Models/LogPersistenceConfiguration.cs

@@ -0,0 +1,11 @@
+using Elsa.Api.Client.Resources.Scripting.Models;
+using Elsa.Api.Client.Shared.Enums;
+
+namespace Elsa.Api.Client.Shared.Models;
+
+public class LogPersistenceConfiguration
+{
+    public LogPersistenceEvaluationMode EvaluationMode { get; set; }
+    public string? StrategyType { get; set; }
+    public Expression? Expression { get; set; }
+}

src/modules/Elsa.JavaScript/Handlers/ConfigureEngineWithCommonTypes.cs

@@ -1,6 +1,7 @@
 using Elsa.Extensions;
 using Elsa.JavaScript.Notifications;
 using Elsa.Mediator.Contracts;
+using Elsa.Workflows.LogPersistence;
 using JetBrains.Annotations;
 
 namespace Elsa.JavaScript.Handlers;
@@ -22,6 +23,7 @@ public Task HandleAsync(EvaluatingJavaScript notification, CancellationToken can
         engine.RegisterType<TimeSpan>();
         engine.RegisterType<Guid>();
         engine.RegisterType<Random>();
+        engine.RegisterType<LogPersistenceMode>();
 
         return Task.CompletedTask;
     }

src/modules/Elsa.JavaScript/Providers/VariableTypeDefinitionProvider.cs

@@ -25,7 +25,7 @@ protected override IEnumerable<TypeDefinition> GetTypeDefinitions(TypeDefinition
         var variableTypeQuery =
             from variable in variables
             let variableType = variable.GetVariableType()
-            where (variableType.IsClass || variableType.IsInterface) && !variableType.IsPrimitive && !excludedTypes.Any(x => x(variableType))
+            where (variableType.IsClass || variableType.IsInterface || variableType.IsEnum) && !variableType.IsPrimitive && !excludedTypes.Any(x => x(variableType))
             select variableType;
 
         var variableTypes = variableTypeQuery.Distinct();

src/modules/Elsa.JavaScript/Services/TypeAliasRegistry.cs

@@ -1,6 +1,7 @@
 using System.Dynamic;
 using Elsa.JavaScript.Contracts;
 using Elsa.JavaScript.Extensions;
+using Elsa.Workflows.LogPersistence;
 
 namespace Elsa.JavaScript.Services;
 
@@ -32,6 +33,7 @@ public TypeAliasRegistry()
         this.RegisterType<DateOnly>("Date");
         this.RegisterType<TimeOnly>("Date");
         this.RegisterType<IDictionary<string, object>>("ObjectDictionary");
+        this.RegisterType<LogPersistenceMode>("LogPersistenceMode");
     }
 
     /// <inheritdoc />

src/modules/Elsa.JavaScript/TypeDefinitions/Services/TypeDefinitionDocumentRenderer.cs

@@ -40,16 +40,25 @@ private void Render(TypeDefinition typeDefinition, StringBuilder output)
     {
         output.AppendLine($"declare {typeDefinition.DeclarationKeyword} {typeDefinition.Name} {{");
 
-        foreach (var property in typeDefinition.Properties)
-            Render(property, output);
-
+        if (typeDefinition.DeclarationKeyword == "enum")
+        {
+            foreach (var property in typeDefinition.Properties)
+                RenderEnumMember(property, output);
+        }
+        else
+        {
+            foreach (var property in typeDefinition.Properties)
+                Render(property, output);
+        }
+
         foreach (var method in typeDefinition.Methods)
             RenderMethod(method, output);
 
         output.AppendLine("}");
     }
 
     private void Render(PropertyDefinition property, StringBuilder output) => output.AppendLine($"{property.Name}{(property.IsOptional ? "?" : "")}: {property.Type};");
+    private void RenderEnumMember(PropertyDefinition property, StringBuilder output) => output.AppendLine($"{property.Name} = \"{property.Name}\";");
     private void Render(VariableDefinition variable, StringBuilder output) => output.AppendLine($"declare var {variable.Name}: {variable.Type};");
     string RenderParameter(ParameterDefinition parameter) => $"{parameter.Name}{(parameter.IsOptional ? "?" : "")}: {parameter.Type}";
     string RenderParameters(IEnumerable<ParameterDefinition> parameters) => string.Join(", ", parameters.Select(RenderParameter));

src/modules/Elsa.JavaScript/TypeDefinitions/Services/TypeDescriber.cs

@@ -36,6 +36,9 @@ public TypeDefinition DescribeType(Type type)
 
     private IEnumerable<FunctionDefinition> GetMethodDefinitions(Type type)
     {
+        if(type.IsEnum)
+            yield break;
+
 #pragma warning disable IL2070
         var methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static).Where(x => !x.IsSpecialName).ToList();
 #pragma warning restore IL2070
@@ -68,6 +71,22 @@ private IEnumerable<ParameterDefinition> GetMethodParameters(MethodInfo method)
 
     private IEnumerable<PropertyDefinition> GetPropertyDefinitions([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type type)
     {
+        // If the type is an enum, enumerate its members.
+        if (type.IsEnum)
+        {
+            foreach (var name in Enum.GetNames(type))
+            {
+                yield return new PropertyDefinition
+                {
+                    Name = name,
+                    Type = "string",
+                    IsOptional = false,
+                };
+            }
+
+            yield break;
+        }
+
         var properties = type.GetProperties();
 
         foreach (var property in properties)
@@ -86,8 +105,8 @@ private static string GetDeclarationKeyword(Type type) =>
         {
             { IsInterface: true } => "interface",
             { IsClass: true } => "class",
-            { IsValueType: true } => "class",
             { IsEnum: true } => "enum",
+            { IsValueType: true, IsEnum: false } => "class",
             _ => "interface"
         };
 }

src/modules/Elsa.Workflows.Core/Extensions/DictionaryExtensions.cs

@@ -9,6 +9,18 @@ public static class DictionaryExtensions
     public static bool TryGetValue<T>(this IDictionary<string, object> dictionary, IEnumerable<string> keys, out T value) => dictionary.TryGetValue<string, T>(keys, out value);
     public static bool TryGetValue<T>(this IDictionary<object, object> dictionary, string key, out T value) => dictionary.TryGetValue<object, T>(key, out value);
 
+    public static bool TryGetValue<TKey, T>(this IDictionary<TKey, T> dictionary, TKey key, out T value)
+    {
+        if (!dictionary.TryGetValue(key, out var item))
+        {
+            value = default!;
+            return false;
+        }
+
+        value = item;
+        return true;
+    }
+
     public static bool TryGetValue<TKey, T>(this IDictionary<TKey, object> dictionary, TKey key, out T value)
     {
         if (!dictionary.TryGetValue(key, out var item))
@@ -38,6 +50,7 @@ public static bool TryGetValue<TKey, T>(this IDictionary<TKey, object> dictionar
 
     public static T? GetValue<TKey, T>(this IDictionary<TKey, T> dictionary, TKey key) => ConvertValue<T>(dictionary[key]);
     public static T? GetValue<T>(this IDictionary<string, object> dictionary, string key) => ConvertValue<T>(dictionary[key]);
+    public static T? GetValueOrDefault<TKey, T>(this IDictionary<TKey, T> dictionary, TKey key, Func<T?> defaultValueFactory) => TryGetValue(dictionary, key, out var value) ? value : defaultValueFactory();
 
     public static T? GetValueOrDefault<TKey, T>(this IDictionary<TKey, object> dictionary, TKey key, Func<T?> defaultValueFactory) => TryGetValue<TKey, T>(dictionary, key, out var value) ? value : defaultValueFactory();
     public static T? GetValueOrDefault<TKey, T>(this IDictionary<TKey, object> dictionary, TKey key) => GetValueOrDefault<TKey, T>(dictionary, key, () => default);

src/modules/Elsa.Workflows.Management/Features/WorkflowManagementFeature.cs

@@ -47,6 +47,7 @@ public class WorkflowManagementFeature : FeatureBase
     private const string LookupsCategory = "Lookups";
     private const string DynamicCategory = "Dynamic";
     private const string DataCategory = "Data";
+    private const string SystemCategory = "System";
 
     private string CompressionAlgorithm { get; set; } = nameof(None);
     private LogPersistenceMode LogPersistenceMode { get; set; } = LogPersistenceMode.Include;
@@ -86,7 +87,8 @@ public WorkflowManagementFeature(IModule module) : base(module)
         new(typeof(JsonNode), DynamicCategory, "A JSON node for reading and writing a JSON structure."),
         new(typeof(JsonObject), DynamicCategory, "A JSON object for reading and writing a JSON structure."),
         new(typeof(byte[]), DataCategory, "A byte array."),
-        new(typeof(Stream), DataCategory, "A stream.")
+        new(typeof(Stream), DataCategory, "A stream."),
+        new(typeof(LogPersistenceMode), SystemCategory, "A LogPersistenceMode enum value.")
     ];
 
     /// <summary>

src/modules/Elsa.Workflows.Runtime/Elsa.Workflows.Runtime.csproj.DotSettings

@@ -1,6 +1,7 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=contexts/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=contracts/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=enums/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=extensions/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=models/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=requests/@EntryIndexedValue">True</s:Boolean>

src/modules/Elsa.Workflows.Runtime/Enums/LogPersistenceEvaluationMode.cs

@@ -0,0 +1,7 @@
+namespace Elsa.Workflows.Runtime;
+
+public enum LogPersistenceEvaluationMode
+{
+    Strategy,
+    Expression
+}

src/modules/Elsa.Workflows.Runtime/Models/LogPersistenceConfiguration.cs

@@ -0,0 +1,10 @@
+using Elsa.Expressions.Models;
+
+namespace Elsa.Workflows.Runtime;
+
+public class LogPersistenceConfiguration
+{
+    public LogPersistenceEvaluationMode EvaluationMode { get; set; }
+    public string? StrategyType { get; set; }
+    public Expression? Expression { get; set; }
+}