Reduce flow boilerplate by introducing an abstract class ontop of IFlow

[catmanjan]

Hello cool project, I was just looking at the quickstart and it would be nice if ConfigureAsync was optional, instead you could have an abstract class e.g. BasicFlow which implements its own ConfigureAsync based on the name of the implementing class, something like this:

using DidactCore.Flows;
using DidactCore.Constants;

public abstract class BasicFlow : IFlow
{
    private readonly IFlowConfigurator _flowConfigurator;

    public BasicFlow(IFlowConfigurator flowConfigurator)
    {
        _flowConfigurator = flowConfigurator;
    }

    public async Task ConfigureAsync()
    {
        await _flowConfigurator
            .WithTypeName(GetType().Name)
            .WithName(Assembly.GetExecutingAssembly().Name)
            .WithDescription(Assembly.GetExecutingAssembly().Name)
            .AsVersion(Assembly.GetExecutingAssembly().Version)
            .ForQueue(QueueTypes.HyperQueue, "Default")
            .SaveConfigurationsAsync();
    }
}

[DMiradakis]

Hi @catmanjan , thanks for the comment! My apologies in my delay getting back to you, I've been super busy finishing up the APIs and supporting classes for Didact v1. Aiming for a release hopefully in January. 😄

So a few things about the example Flow I have in the docs has actually changed. As I've been building out the execution mechanism in Didact Engine, I've actually changed the ConfigureAsync method to a Configure method that simply returns the IFlowConfigurator. And the metadata configs are saved to the database via some internal processes in Didact Engine. The docsite is still very outdated, but I have tons of changes coming to it very soon!

Regarding your idea about the abstract class:

The Flow metadata is essential to Didact working the way that it will, so I don't really see a way forward to making Flows work as I envision them without enforcing a Configure method that returns the IFlowConfigurator. This configurator is - as mentioned above - saved to Didact's database at runtime, and this metadata is then used to create, instantiate, and execution FlowRuns in Didact Engine. As a result of that, I think that the Configure method needs to be enforced via the IFlow interface.

Another big issue with using an abstract class is that each Flow in your flow libraries needs to be dynamically instantiated via the library dependency injection systems (super super complex stuff I've been working out for quite a while). To dynamically instantiate these Flow types, cast them to IFlows, and then execute them, they are required not to be abstract.

So I think unfortunately this approach won't work well for Didact Engine's execution mechanisms. Do you have any further thoughts on this? Always happy to hear further input!