Reorganize and support recursive simple name resolution for signal re…

…sults (#13)

samples/Controllers/OperationOrchestratorController.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Threading.Tasks;
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using PSIBR.Liminality;
+
+namespace Samples.Controllers
+{
+    [ApiController]
+    [Route("[controller]")]
+    public class OperationOrchestratorController : ControllerBase
+    {
+        private readonly ILogger<OperationOrchestratorController> _logger;
+
+        public OperationOrchestratorController(
+            ILogger<OperationOrchestratorController> logger)
+        {
+            _logger = logger;
+        }
+
+        [HttpPost]
+        public async Task<IActionResult> Post(OperationOrchestrator.Request request, [FromServices] OperationOrchestrator.Repository operationOrchestrationRepository)
+        {
+            var operationOrchestrator = operationOrchestrationRepository.Find(Guid.NewGuid().ToString());
+
+            var requestResult = await operationOrchestrator.SignalAsync(request);
+
+            if (requestResult.InnerResult is not TransitionedResult transitionResult
+                || transitionResult.NewState is not OperationOrchestrator.Requesting.Requested)
+
+            {
+                return Problem(statusCode: 500);
+            }
+
+            var startResult = await operationOrchestrator.SignalAsync(new OperationOrchestrator.Start());
+
+            if (startResult.InnerResult is not TransitionedResult transitionResult2
+                || transitionResult2.NewState is not OperationOrchestrator.InProgress)
+            {
+                return Problem(statusCode: 500);
+            }
+
+            return Ok(AggregateSignalResult.Combine(requestResult, startResult));
+        }
+    }
+}

samples/OperationOrchestrator.Cancelled.cs

@@ -0,0 +1,8 @@
+namespace Samples
+{
+    public partial class OperationOrchestrator
+    {
+        public class Cancelled { }
+
+    }
+}

samples/OperationOrchestrator.Cancelling.cs

@@ -0,0 +1,12 @@
+using PSIBR.Liminality;
+
+namespace Samples
+{
+    public partial class OperationOrchestrator
+    {
+        [Transition<Throw, Failed>]
+        [Transition<Cancel.Acknowledgement, Cancelled>]
+        public class Cancelling { }
+
+    }
+}

samples/OperationOrchestrator.Completed.cs

@@ -0,0 +1,8 @@
+namespace Samples
+{
+    public partial class OperationOrchestrator
+    {
+        public class Completed { }
+
+    }
+}

samples/OperationOrchestrator.Created.cs

@@ -0,0 +1,11 @@
+using PSIBR.Liminality;
+
+namespace Samples
+{
+    public partial class OperationOrchestrator
+    {
+        [Transition<Request, Requesting>]
+        public class Created { }
+
+    }
+}

samples/OperationOrchestrator.Failed.cs

@@ -0,0 +1,8 @@
+namespace Samples
+{
+    public partial class OperationOrchestrator
+    {
+        public class Failed { }
+
+    }
+}

samples/OperationOrchestrator.InProgress.cs

@@ -0,0 +1,29 @@
+using PSIBR.Liminality;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Samples
+{
+    public partial class OperationOrchestrator
+    {
+        [Transition<Ping, InProgress>]
+        [Transition<Pause, Pausing>]
+        [Transition<Complete, Completed>]
+        [Transition<Cancel, Cancelling>]
+        [Transition<Throw, Failed>]
+        public class InProgress
+            : IAfterEnterHandler<OperationOrchestrator, Start>
+        {
+            public ValueTask<AggregateSignalResult?> AfterEnterAsync(SignalContext<OperationOrchestrator> context, Start signal, CancellationToken cancellationToken = default)
+            {
+                //do work
+
+                // if the work is in the state machine,
+                // you probably want some extra form of checkpointing and break up long processes.
+                // Additionally you could add cancellation via a subscription your state store on the Cancelling state's after entry action
+                return default;
+            }
+        }
+
+    }
+}

samples/OperationOrchestrator.Paused.cs

@@ -0,0 +1,11 @@
+using PSIBR.Liminality;
+
+namespace Samples
+{
+    public partial class OperationOrchestrator
+    {
+        [Transition<Resume, Requesting.Requested>]
+        public class Paused { }
+
+    }
+}

samples/OperationOrchestrator.Pausing.cs

@@ -0,0 +1,12 @@
+using PSIBR.Liminality;
+
+namespace Samples
+{
+    public partial class OperationOrchestrator
+    {
+        [Transition<Throw, Failed>]
+        [Transition<Cancel, Cancelled>]
+        public class Pausing { }
+
+    }
+}

samples/OperationOrchestrator.Repository.cs

@@ -0,0 +1,22 @@
+using PSIBR.Liminality;
+
+namespace Samples
+{
+    public partial class OperationOrchestrator
+    {
+        public class Repository
+        {
+            private readonly LiminalEngine _engine;
+            private readonly StateMachineDefinition<OperationOrchestrator> _definition;
+
+            public Repository(LiminalEngine engine, StateMachineDefinition<OperationOrchestrator> definition)
+            {
+                _engine = engine;
+                _definition = definition;
+            }
+
+            public OperationOrchestrator Find(string orchestrationId) => new(_engine, _definition, orchestrationId);
+        }
+
+    }
+}