Added custom serializable functionality

Author: stidsborg

Core/Cleipnir.ResilientFunctions.Tests/InMemoryTests/RFunctionTests/EffectTests.cs

@@ -61,4 +61,8 @@ public override Task ExceptionThrownInsideEffectBecomesFatalWorkflowException()
     [TestMethod]
     public override Task ExceptionThrownInsideEffectStaysFatalWorkflowException()
         => ExceptionThrownInsideEffectStaysFatalWorkflowException(FunctionStoreFactory.Create());
+
+    [TestMethod]
+    public override Task EffectCanReturnOption()
+        => EffectCanReturnOption(FunctionStoreFactory.Create());
 }

Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/RFunctionTests/EffectTests.cs

@@ -5,8 +5,8 @@
 using Cleipnir.ResilientFunctions.CoreRuntime.Invocation;
 using Cleipnir.ResilientFunctions.CoreRuntime.Serialization;
 using Cleipnir.ResilientFunctions.Domain;
-using Cleipnir.ResilientFunctions.Domain.Exceptions;
 using Cleipnir.ResilientFunctions.Helpers;
+using Cleipnir.ResilientFunctions.Reactive.Utilities;
 using Cleipnir.ResilientFunctions.Storage;
 using Cleipnir.ResilientFunctions.Tests.Utils;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -541,4 +541,39 @@ public async Task ExceptionThrownInsideEffectStaysFatalWorkflowException(Task<IF
         }
         Assert.Fail("Expected FatalWorkflowException<InvalidOperationException>");
     }
+    
+    public abstract Task EffectCanReturnOption();
+    public async Task EffectCanReturnOption(Task<IFunctionStore> storeTask)
+    {
+        var store = await storeTask;
+        using var functionsRegistry = new FunctionsRegistry(store);
+        var flowId = TestFlowId.Create();
+        var (flowType, flowInstance) = flowId;
+        var rAction = functionsRegistry.RegisterFunc(
+            flowType,
+            async Task<Option<string>> (string message, Workflow workflow) =>
+            {
+                var (effect, _, _) = workflow;
+                return await effect.Capture(
+                    id: "Test",
+                    work: () => Option.Create(message)
+                );
+            });
+
+        var result = await rAction.Invoke(flowInstance.ToString(), "Hello!");
+        result.HasValue.ShouldBeTrue();
+        result.Value.ShouldBe("Hello!");
+        
+        var controlPanel = await rAction.ControlPanel(flowId.Instance);
+        controlPanel.ShouldNotBeNull();
+
+        var effectValue = await controlPanel.Effects.GetValue<Option<string>>("Test");
+        effectValue.ShouldNotBeNull();
+        effectValue.HasValue.ShouldBeTrue();
+        effectValue.Value.ShouldBe("Hello!");
+        
+        result = await controlPanel.Restart();
+        result.HasValue.ShouldBeTrue();
+        result.Value.ShouldBe("Hello!");
+    }
 }

Core/Cleipnir.ResilientFunctions/CoreRuntime/Invocation/InvocationHelper.cs

@@ -32,7 +32,7 @@ public InvocationHelper(FlowType flowType, StoredType storedType, bool isParamle
         _isParamlessFunction = isParamlessFunction;
         _settings = settings;
 
-        Serializer = new ErrorHandlingDecorator(settings.Serializer);
+        Serializer = new ErrorHandlingDecorator(new CustomSerializableDecorator(settings.Serializer));
         _shutdownCoordinator = shutdownCoordinator;
         _leaseUpdaters = leaseUpdaters;
         _storedType = storedType;

Core/Cleipnir.ResilientFunctions/CoreRuntime/Serialization/CustomSerializableDecorator.cs

@@ -3,11 +3,10 @@
 using System.Reflection;
 using System.Threading;
 using Cleipnir.ResilientFunctions.Domain;
-using Cleipnir.ResilientFunctions.Helpers;
 using Cleipnir.ResilientFunctions.Storage;
 
 namespace Cleipnir.ResilientFunctions.CoreRuntime.Serialization;
-/*
+
 public class CustomSerializableDecorator : ISerializer
 {
     private readonly ISerializer _inner;
@@ -16,65 +15,32 @@ public class CustomSerializableDecorator : ISerializer
 
     public CustomSerializableDecorator(ISerializer inner) => _inner = inner;
 
-    public byte[] SerializeParameter<TParam>(TParam parameter) 
+    public byte[] Serialize<T>(T parameter) 
         => parameter is ICustomSerializable customSerializable
             ? customSerializable.Serialize(this)
-            : _inner.SerializeParameter(parameter);
+            : _inner.Serialize(parameter);
 
-    public TParam DeserializeParameter<TParam>(byte[] json)
-    {
-        return typeof(TParam).IsAssignableTo(typeof(ICustomSerializable)) 
-            ? CustomDeserialize<TParam>(json) 
-            : _inner.DeserializeParameter<TParam>(json);
-    }
+    public T Deserialize<T>(byte[] json) 
+        => typeof(T).IsAssignableTo(typeof(ICustomSerializable)) 
+            ? CustomDeserialize<T>(json) 
+            : _inner.Deserialize<T>(json);
 
     public StoredException SerializeException(FatalWorkflowException exception)
         => _inner.SerializeException(exception);
 
     public FatalWorkflowException DeserializeException(FlowId flowId, StoredException storedException) 
         => _inner.DeserializeException(flowId, storedException);
 
-    public byte[] SerializeResult<TResult>(TResult result)
-        => result is ICustomSerializable customSerializable
-            ? customSerializable.Serialize(this)
-            : _inner.SerializeResult(result);
-    
-    public TResult DeserializeResult<TResult>(byte[] json) 
-    {
-        return typeof(TResult).IsAssignableTo(typeof(ICustomSerializable)) 
-            ? CustomDeserialize<TResult>(json) 
-            : _inner.DeserializeParameter<TResult>(json);
-    }
-
     public SerializedMessage SerializeMessage<TEvent>(TEvent message) where TEvent : notnull
         => _inner.SerializeMessage(message); //todo allow custom serializer
     public object DeserializeMessage(byte[] json, byte[] type) => _inner.DeserializeMessage(json, type);
-
-    public byte[] SerializeEffectResult<TResult>(TResult result)
-        => result is ICustomSerializable customSerializable
-            ? customSerializable.Serialize(this)
-            : _inner.SerializeEffectResult(result);
-    
-    public TResult DeserializeEffectResult<TResult>(byte[] json)
-    {
-        return typeof(TResult).IsAssignableTo(typeof(ICustomSerializable)) 
-            ? CustomDeserialize<TResult>(json) 
-            : _inner.DeserializeEffectResult<TResult>(json);
-    }
-
-    public byte[] SerializeState<TState>(TState state) where TState : FlowState, new()
-        => _inner.SerializeState(state);
-    public TState DeserializeState<TState>(byte[] json) where TState : FlowState, new()
-        => _inner.DeserializeState<TState>(json);
 
     private T CustomDeserialize<T>(byte[] bytes)
     {
         lock (_lock)
         {
             if (!_deserializers.ContainsKey(typeof(T)))
             {
-                //var serializeMethodInfo = typeof(T).GetMethod(nameof(ICustomSerializable.Serialize), BindingFlags.Public | BindingFlags.Static);
-                //var serializeFunc = (Func<ISerializer, byte[]>) Delegate.CreateDelegate(typeof(Func<ISerializer, byte[]>), serializeMethodInfo!);
                 var deserializeMethodInfo = typeof(T).GetMethod(nameof(ICustomSerializable.Deserialize), BindingFlags.Public | BindingFlags.Static);
                 var deserializeFunc = (Func<byte[], ISerializer, object>) Delegate.CreateDelegate(typeof(Func<byte[], ISerializer, object>), deserializeMethodInfo!);
                 _deserializers[typeof(T)] = deserializeFunc;
@@ -83,4 +49,4 @@ private T CustomDeserialize<T>(byte[] bytes)
             return (T) _deserializers[typeof(T)](bytes, this);
         }
     }
-}*/
+}

Core/Cleipnir.ResilientFunctions/Reactive/Utilities/Option.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Text.Json.Serialization;
 using System.Threading.Tasks;
+using Cleipnir.ResilientFunctions.CoreRuntime.Serialization;
 
 namespace Cleipnir.ResilientFunctions.Reactive.Utilities;
 
@@ -28,6 +29,27 @@ public override bool Equals(object? obj)
         return Value!.Equals(option.Value);
     }
     public override int GetHashCode() => !HasValue ? 0 : Value!.GetHashCode();
+
+    public byte[] Serialize(ISerializer serializer)
+    {
+        if (!HasValue)
+            return [];
+        
+        var valueBytes = serializer.Serialize(Value);
+        var bytes = new byte[valueBytes.Length + 1];
+        bytes[0] = 1;
+        valueBytes.CopyTo(bytes, index: 1);
+        return bytes;
+    }
+
+    public static object Deserialize(byte[] bytes, ISerializer serializer)
+    {
+        if (bytes[0] == 0)
+            return NoValue;
+
+        var value = (T) serializer.Deserialize<T>(bytes[1..])!;
+        return new Option<T>(value, hasValue: true);
+    }
 }
 
 public static class Option

Stores/MariaDB/Cleipnir.ResilientFunctions.MariaDB.Tests/RFunctionTests/EffectTests.cs

@@ -60,4 +60,8 @@ public override Task ExceptionThrownInsideEffectBecomesFatalWorkflowException()
     [TestMethod]
     public override Task ExceptionThrownInsideEffectStaysFatalWorkflowException()
         => ExceptionThrownInsideEffectStaysFatalWorkflowException(FunctionStoreFactory.Create());
+    
+    [TestMethod]
+    public override Task EffectCanReturnOption()
+        => EffectCanReturnOption(FunctionStoreFactory.Create());
 }

Stores/PostgreSQL/Cleipnir.ResilientFunctions.PostgreSQL.Tests/RFunctionTests/EffectTests.cs

@@ -61,4 +61,8 @@ public override Task ExceptionThrownInsideEffectBecomesFatalWorkflowException()
     [TestMethod]
     public override Task ExceptionThrownInsideEffectStaysFatalWorkflowException()
         => ExceptionThrownInsideEffectStaysFatalWorkflowException(FunctionStoreFactory.Create());
+    
+    [TestMethod]
+    public override Task EffectCanReturnOption()
+        => EffectCanReturnOption(FunctionStoreFactory.Create());
 }

Stores/SqlServer/Cleipnir.ResilientFunctions.SqlServer.Tests/EffectTests.cs

@@ -61,4 +61,8 @@ public override Task ExceptionThrownInsideEffectBecomesFatalWorkflowException()
     [TestMethod]
     public override Task ExceptionThrownInsideEffectStaysFatalWorkflowException()
         => ExceptionThrownInsideEffectStaysFatalWorkflowException(FunctionStoreFactory.Create());   
+
+    [TestMethod]
+    public override Task EffectCanReturnOption()
+        => EffectCanReturnOption(FunctionStoreFactory.Create());
 }