Update README.md

Add generic type constraints to ListTransitionsRequest in Query.cs

.config/dotnet-tools.json

@@ -3,16 +3,16 @@
   "isRoot": true,
   "tools": {
     "dotnet-sonarscanner": {
-      "version": "5.7.2",
+      "version": "6.2.0",
       "commands": [
         "dotnet-sonarscanner"
       ]
     },
     "dotnet-coverage": {
-      "version": "17.3.2",
+      "version": "17.11.0",
       "commands": [
         "dotnet-coverage"
       ]
     }
   }
-}
+}

.github/dependabot.yml

@@ -4,7 +4,6 @@ updates:
   # Maintain dependencies for GitHub Actions
   - package-ecosystem: "github-actions"
     directory: "/"
-    target-branch: dev
     schedule:
       interval: "daily"
     reviewers:
@@ -13,8 +12,7 @@ updates:
   # Maintain dependencies for nuget
   - package-ecosystem: "nuget"
     directory: "/"
-    target-branch: dev
     schedule:
       interval: "daily"
     reviewers:
-      - "ditkrg/digital-development-net"
+      - "ditkrg/dotnet"

.github/workflows/deploy-nuget.yaml

@@ -1,3 +1,4 @@
+---
 name: Deploy To Nuget
 
 on:
@@ -19,13 +20,13 @@ jobs:
   build-push:
     name: Build and Publish
     needs: [test]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
-      - uses: actions/setup-dotnet@v1
+      - uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: "6.0.x"
+          dotnet-version: "8.0.x"
 
       - name: Restore packages
         run: dotnet restore

.github/workflows/sonarqube.yaml

@@ -1,3 +1,4 @@
+---
 name: Run SonarQube Analysis
 
 on:
@@ -13,39 +14,10 @@ concurrency:
   group: sonarqube-analysis
 
 jobs:
-  run-tests:
-    name: Run SonarQube Analysis
-    timeout-minutes: 10
-    runs-on: ubuntu-latest
-
-    env:
-      PROJECT_KEY: ditkrg_DIT.Workflower_AYF14rjSb80e2b0bns3t
-      SONARQUBE_HOST: ${{ secrets.SONARQUBE_HOST }}
+  test:
+    uses: ./.github/workflows/tests-base.yaml
+    with:
+      sonarqube: true
+      sonarqube_host: ${{ vars.SONARQUBE_HOST }}
+    secrets:
       SONARQUBE_TOKEN: ${{ secrets.SONARQUBE_TOKEN }}
-      ASPNETCORE_ENVIRONMENT: Testing
-
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0 # Shallow clones should be disabled for a better relevancy of analysis
-
-      - name: Set up JDK 11
-        uses: actions/setup-java@v3
-        with:
-          distribution: "zulu"
-          java-version: "11"
-
-      - name: Restore tools
-        run: dotnet tool restore
-
-      - name: Run Tests (SonarQube)
-        run: |
-          dotnet tool run dotnet-sonarscanner begin -k:"$PROJECT_KEY" \
-            -d:sonar.login="$SONARQUBE_TOKEN" \
-            -d:sonar.host.url="$SONARQUBE_HOST" \
-            -d:sonar.cs.vscoveragexml.reportsPaths=coverage.xml
-
-          dotnet build --no-incremental
-          dotnet dotnet-coverage collect "dotnet test" -f xml -o "coverage.xml"
-
-          dotnet tool run dotnet-sonarscanner end -d:sonar.login="$SONARQUBE_TOKEN"

.github/workflows/tests-base.yaml

@@ -12,6 +12,19 @@ on:
       - "!.github/workflows/tests-base.yaml"
 
   workflow_call:
+    inputs:
+      sonarqube:
+        type: boolean
+        required: false
+        default: false
+
+      sonarqube_host:
+        type: string
+        required: false
+
+    secrets:
+      SONARQUBE_TOKEN:
+        required: false
 
 jobs:
   run-tests:
@@ -23,11 +36,49 @@ jobs:
       ASPNETCORE_ENVIRONMENT: Testing
 
     steps:
-      - uses: actions/checkout@v3
-
-      - uses: actions/setup-dotnet@v2
+      - uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: "6.0.x"
+          dotnet-version: "8.0.x"
+
+      - uses: actions/checkout@v4
+        if: ${{ !inputs.sonarqube }}
 
       - name: Run tests
+        if: ${{ !inputs.sonarqube }}
         run: dotnet test
+
+      ###############################
+      ########## SONARQUBE ##########
+      ###############################
+      - name: Set up JDK
+        uses: actions/setup-java@v4
+        if: ${{ inputs.sonarqube }}
+        with:
+          distribution: "zulu"
+          java-version: "17"
+
+      - uses: actions/checkout@v4
+        if: ${{ inputs.sonarqube }}
+        with:
+          fetch-depth: 0 # Shallow clones should be disabled for a better relevancy of analysis
+
+      - name: Restore tools
+        if: ${{ inputs.sonarqube }}
+        run: dotnet tool restore
+
+      - name: Run tests (SonarQube)
+        if: ${{ inputs.sonarqube }}
+        env:
+          PROJECT_KEY: ditkrg_DIT.Workflower_AYF14rjSb80e2b0bns3t
+          SONARQUBE_HOST: ${{ inputs.sonarqube_host }}
+          SONARQUBE_TOKEN: ${{ secrets.SONARQUBE_TOKEN }}
+        run: |
+          dotnet tool run dotnet-sonarscanner begin -k:"$PROJECT_KEY" \
+            -d:sonar.login="$SONARQUBE_TOKEN" \
+            -d:sonar.host.url="$SONARQUBE_HOST" \
+            -d:sonar.cs.vscoveragexml.reportsPaths=coverage.xml
+
+          dotnet build --no-incremental
+          dotnet dotnet-coverage collect "dotnet test" -f xml -o "coverage.xml"
+
+          dotnet tool run dotnet-sonarscanner end -d:sonar.login="$SONARQUBE_TOKEN"

README.md

@@ -8,15 +8,15 @@ Workflower is a library based on .NET Standard, To handle Finite State Machines
 
 Install the latest nuget package into your ASP.NET Core application.
 
-    ```sh
-    dotnet add package DIT.Workflower
-    ```
+```sh
+dotnet add package DIT.Workflower
+```
 
-    You can also download support for Dependency Injection:
+You can also download support for Dependency Injection:
 
-    ```sh
-    dotnet add package DIT.Workflower.DependencyInjection
-    ```
+```sh
+dotnet add package DIT.Workflower.DependencyInjection
+```
 
 ### Workflow Builder
 

src/DIT.Workflower.DependencyInjection/Abstractions/IWorkflow.cs

@@ -10,6 +10,15 @@ public interface IWorkflow<TState, TCommand, TContext>
 
     string Reference => $"{Id}.v{Version}";
 
+    /// <summary>
+    /// Retrieves all transition definitions for the workflow.
+    /// </summary>
+    /// <typeparam name="TState">The type of the workflow state.</typeparam>
+    /// <typeparam name="TCommand">The type of the workflow command.</typeparam>
+    /// <typeparam name="TContext">The type of the workflow context.</typeparam>
+    /// <returns>A list of transition definitions.</returns>
+    public List<TransitionDefinition<TState, TCommand, ContextWrapper<TContext>>> GetAllTransitionDefinitions();
+
     /// <summary>
     /// Gets a list of allowed transitions without any condition checks.
     /// </summary>
@@ -24,4 +33,13 @@ public interface IWorkflow<TState, TCommand, TContext>
     /// <param name="from">The incoming state</param>
     /// <returns>A list of available transitions for the current context</returns>
     public List<Transition<TState, TCommand>> GetAllowedTransitions(TContext context, TState from);
+
+    /// <summary>
+    /// Retrieves a list of allowed transitions based on the provided request.
+    /// </summary>
+    /// <typeparam name="TState">The type of the workflow state.</typeparam>
+    /// <typeparam name="TCommand">The type of the workflow command.</typeparam>
+    /// <param name="request">The request object containing the necessary information.</param>
+    /// <returns>An enumerable of allowed transitions.</returns>
+    public IEnumerable<Transition<TState, TCommand>> GetAllowedTransitions(ListTransitionsRequest<TState, TCommand, TContext> request);
 }

src/DIT.Workflower.DependencyInjection/Common.cs

@@ -1,3 +1,3 @@
 namespace DIT.Workflower.DependencyInjection;
 
-public record DIContextWrapper<TContext>(TContext Context, IServiceProvider ServiceProvider);
+public record ContextWrapper<TContext>(TContext Context, IServiceProvider ServiceProvider);

src/DIT.Workflower.DependencyInjection/DIT.Workflower.DependencyInjection.csproj

@@ -1,13 +1,29 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFrameworks>net6.0;net7.0;net8.0</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+
+    <IsPackable>true</IsPackable>
+    <PackageId>DIT.Workflower.DependencyInjection</PackageId>
+    <Authors>DIT</Authors>
+    <Company>DIT</Company>
+
+    <!-- Symbols for nuget -->
+    <IncludeSymbols>true</IncludeSymbols>
+    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+
+    <!-- Deterministic Builds -->
+    <EmbedUntrackedSources>true</EmbedUntrackedSources>
+    <ContinuousIntegrationBuild Condition="'$(CI)' == 'true'">true</ContinuousIntegrationBuild>
+
   </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="6.0.0" />
+  <ItemGroup >
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="8.0.1" Condition="'$(TargetFramework)' == 'net6.0'" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="8.0.1" Condition="'$(TargetFramework)' == 'net7.0'" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="8.0.1" Condition="'$(TargetFramework)' == 'net8.0'" />
   </ItemGroup>
 
   <ItemGroup>

src/DIT.Workflower.DependencyInjection/Extensions/IServiceCollectionExtensions.cs

@@ -2,10 +2,10 @@
 
 namespace DIT.Workflower.DependencyInjection.Extensions;
 
-public static class IServiceCollectionExtensions
+public static class ServiceCollectionExtensions
 {
-
-    public static ITransitionStart<TState, TCommand, DIContextWrapper<TContext>> AddWorkflowDefinition<TState, TCommand, TContext>(this IServiceCollection services, in int version = 1)
+    public static ITransitionStart<TState, TCommand, ContextWrapper<TContext>> AddWorkflowDefinition<TState, TCommand, TContext>(
+        this IServiceCollection services, in int version = 1)
         where TState : struct
         where TCommand : struct
     {
@@ -13,25 +13,27 @@ public static class IServiceCollectionExtensions
         return AddWorkflowDefinition<TState, TCommand, TContext>(services, id, version);
     }
 
-    public static ITransitionStart<TState, TCommand, DIContextWrapper<TContext>> AddWorkflowDefinition<TState, TCommand, TContext>(this IServiceCollection services, in string id)
+    public static ITransitionStart<TState, TCommand, ContextWrapper<TContext>> AddWorkflowDefinition<TState, TCommand, TContext>(
+        this IServiceCollection services, in string id)
         where TState : struct
         where TCommand : struct
     {
         return AddWorkflowDefinition<TState, TCommand, TContext>(services, id, version: 1);
     }
 
-    public static ITransitionStart<TState, TCommand, DIContextWrapper<TContext>> AddWorkflowDefinition<TState, TCommand, TContext>(this IServiceCollection services, string id, int version)
+    public static ITransitionStart<TState, TCommand, ContextWrapper<TContext>> AddWorkflowDefinition<TState, TCommand, TContext>(
+        this IServiceCollection services, string id, int version)
         where TState : struct
         where TCommand : struct
     {
-        var builder = WorkflowDefinitionBuilder<TState, TCommand, DIContextWrapper<TContext>>.Create();
+        var builder = WorkflowDefinitionBuilder<TState, TCommand, ContextWrapper<TContext>>.Create();
+        var definition = (WorkflowDefinitionBuilder<TState, TCommand, ContextWrapper<TContext>>)builder;
 
-        services.TryAddSingleton<IWorkflowFactory<TState, TCommand, DIContextWrapper<TContext>>, DefaultWorkflowFactory<TState, TCommand, DIContextWrapper<TContext>>>();
+        services.TryAddScoped<IWorkflowFactory<TState, TCommand, TContext>, DefaultWorkflowFactory<TState, TCommand, TContext>>();
 
-        services.AddSingleton<IWorkflow<TState, TCommand, DIContextWrapper<TContext>>, WorkflowDefinitionWrapper<TState, TCommand, DIContextWrapper<TContext>>>(sp =>
+        services.AddScoped<IWorkflow<TState, TCommand, TContext>, WorkflowDefinitionWrapper<TState, TCommand, TContext>>(sp =>
         {
-            var definition = (WorkflowDefinitionBuilder<TState, TCommand, DIContextWrapper<TContext>>)builder;
-            var wrapper = new WorkflowDefinitionWrapper<TState, TCommand, DIContextWrapper<TContext>>(definition, id, version);
+            var wrapper = new WorkflowDefinitionWrapper<TState, TCommand, TContext>(definition, sp, id, version);
             return wrapper;
         });
 

src/DIT.Workflower.DependencyInjection/Extensions/IServiceProviderExtensions.cs

@@ -1,22 +1,22 @@
 namespace DIT.Workflower.DependencyInjection.Extensions;
 
-public static class IServiceProviderExtensions
+public static class ServiceProviderExtensions
 {
-    public static IWorkflowFactory<TState, TCommand, DIContextWrapper<TContext>> GetRequiredWorkflowFactory<TState, TCommand, TContext>(this IServiceProvider sp)
+    public static IWorkflowFactory<TState, TCommand, TContext> GetRequiredWorkflowFactory<TState, TCommand, TContext>(this IServiceProvider sp)
         where TState : struct
         where TCommand : struct
     {
-        return sp.GetRequiredService<IWorkflowFactory<TState, TCommand, DIContextWrapper<TContext>>>();
+        return sp.GetRequiredService<IWorkflowFactory<TState, TCommand, TContext>>();
     }
 
-    public static IWorkflowFactory<TState, TCommand, DIContextWrapper<TContext>>? GetWorkflowFactory<TState, TCommand, TContext>(this IServiceProvider sp)
+    public static IWorkflowFactory<TState, TCommand, TContext>? GetWorkflowFactory<TState, TCommand, TContext>(this IServiceProvider sp)
         where TState : struct
         where TCommand : struct
     {
-        return sp.GetService<IWorkflowFactory<TState, TCommand, DIContextWrapper<TContext>>>();
+        return sp.GetService<IWorkflowFactory<TState, TCommand, TContext>>();
     }
 
-    public static IWorkflow<TState, TCommand, DIContextWrapper<TContext>> CreateWorkflow<TState, TCommand, TContext>(this IServiceProvider sp, int version = 1)
+    public static IWorkflow<TState, TCommand, TContext> CreateWorkflow<TState, TCommand, TContext>(this IServiceProvider sp, int version = 1)
         where TState : struct
         where TCommand : struct
     {
@@ -24,7 +24,7 @@ public static class IServiceProviderExtensions
         return factory.CreateWorkflow(version);
     }
 
-    public static IWorkflow<TState, TCommand, DIContextWrapper<TContext>> CreateWorkflow<TState, TCommand, TContext>(this IServiceProvider sp, string id, int version = 1)
+    public static IWorkflow<TState, TCommand, TContext> CreateWorkflow<TState, TCommand, TContext>(this IServiceProvider sp, string id, int version = 1)
         where TState : struct
         where TCommand : struct
     {

src/DIT.Workflower.DependencyInjection/WorkflowDefinitionWrapper.cs

@@ -1,21 +1,56 @@
 namespace DIT.Workflower.DependencyInjection;
 
-public record WorkflowDefinitionWrapper<TState, TCommand, TContext> : WorkflowDefinition<TState, TCommand, TContext>, IWorkflow<TState, TCommand, TContext>
+public sealed class WorkflowDefinitionWrapper<TState, TCommand, TContext> : IWorkflow<TState, TCommand, TContext>
     where TState : struct
     where TCommand : struct
 {
 
+    private readonly IServiceProvider _serviceProvider;
+    private readonly WorkflowDefinition<TState, TCommand, ContextWrapper<TContext>> _definition;
+
     public string Id { get; }
 
     public int Version { get; }
-
-    public WorkflowDefinitionWrapper(WorkflowDefinitionBuilder<TState, TCommand, TContext> builder, string id, int version)
-        : base(builder.Transitions)
+    public List<TransitionDefinition<TState, TCommand, ContextWrapper<TContext>>> GetAllTransitionDefinitions()
     {
+        return _definition.GetAllTransitionDefinitions();
+    }
+
+    public List<Transition<TState, TCommand>> GetAllowedTransitions(TState from)
+    {
+        return _definition.GetAllowedTransitions(from);
+    }
+
+    public List<Transition<TState, TCommand>> GetAllowedTransitions(TContext context, TState from)
+    {
+        return _definition.GetAllowedTransitions(GetContextWrapper(context), from);
+    }
+
+    public IEnumerable<Transition<TState, TCommand>> GetAllowedTransitions(ListTransitionsRequest<TState, TCommand, TContext> request)
+    {
+        var wrappedRequest = new ListTransitionsRequest<TState, TCommand, ContextWrapper<TContext>>
+        {
+            From = request.From,
+            To = request.To,
+            Command = request.Command,
+            Context = request.Context is null ? null : GetContextWrapper(request.Context)
+        };
+
+        return _definition.GetAllowedTransitions(wrappedRequest);
+    }
+
+    public WorkflowDefinitionWrapper(WorkflowDefinitionBuilder<TState, TCommand, ContextWrapper<TContext>> builder, IServiceProvider serviceProvider, string id, int version)
+    {
+        _definition = builder.Build();
+        _serviceProvider = serviceProvider;
+
         Id = id;
         Version = version;
     }
 
+    private ContextWrapper<TContext> GetContextWrapper(in TContext context)
+        => new(context, _serviceProvider);
+
     public static string GetDefaultId()
     {
         var ctxType = typeof(TContext);

src/DIT.Workflower/DIT.Workflower.csproj

@@ -5,6 +5,20 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
 	  <LangVersion>latest</LangVersion>
+
+    <IsPackable>true</IsPackable>
+    <PackageId>DIT.Workflower</PackageId>
+    <Authors>DIT</Authors>
+    <Company>DIT</Company>
+
+    <!-- Symbols for nuget -->
+    <IncludeSymbols>true</IncludeSymbols>
+    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+
+    <!-- Deterministic Builds -->
+    <EmbedUntrackedSources>true</EmbedUntrackedSources>
+    <ContinuousIntegrationBuild Condition="'$(CI)' == 'true'">true</ContinuousIntegrationBuild>
+
   </PropertyGroup>
 
 </Project>

src/DIT.Workflower/Query.cs

@@ -0,0 +1,15 @@
+namespace DIT.Workflower;
+
+
+public sealed class ListTransitionsRequest<TState, TCommand, TContext>
+    where TState : struct
+    where TCommand : struct
+{
+    public TState? From { get; set; }
+
+    public TState? To { get; set; }
+
+    public TCommand? Command { get; set; }
+
+    public TContext? Context { get; set; }
+}

src/DIT.Workflower/WorkflowDefinition.cs

@@ -1,6 +1,6 @@
 namespace DIT.Workflower;
 
-public record WorkflowDefinition<TState, TCommand, TContext>
+public class WorkflowDefinition<TState, TCommand, TContext>
     where TState : struct
     where TCommand : struct
 {
@@ -12,6 +12,8 @@ public record WorkflowDefinition<TState, TCommand, TContext>
         _transitions = transitions;
     }
 
+    public List<TransitionDefinition<TState, TCommand, TContext>> GetAllTransitionDefinitions() => _transitions;
+
     /// <summary>
     /// Lists all allowed transitions from current state for the given context.
     /// </summary>
@@ -33,4 +35,33 @@ public record WorkflowDefinition<TState, TCommand, TContext>
 
         return query.Select(x => x.ToTransition()).ToList();
     }
+
+
+    public IEnumerable<Transition<TState, TCommand>> GetAllowedTransitions(ListTransitionsRequest<TState, TCommand, TContext> request)
+    {
+        var query = _transitions.AsQueryable();
+
+        if (request.From is { } from)
+        {
+            query = query.Where(doc => doc.From.Equals(from));
+        }
+
+        if (request.To is { } to)
+        {
+            query = query.Where(doc => doc.To.Equals(to));
+        }
+
+        if (request.Command is { } command)
+        {
+            query = query.Where(doc => doc.Command.Equals(command));
+        }
+
+        if (request.Context is not null)
+        {
+            query = query.Where(doc => doc.Conditions == null || doc.Conditions.All(cond => cond(request.Context)));
+        }
+
+        return query.Select(x => x.ToTransition());
+    }
+
 }

tests/DIT.Workflower.Tests/DIT.Workflower.Tests.csproj

@@ -9,14 +9,14 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0" />
-    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.2" />
+    <PackageReference Include="xunit" Version="2.4.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="3.1.2">
+    <PackageReference Include="coverlet.collector" Version="3.2.0">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>

tests/DIT.Workflower.Tests/DependencyInjection/DependencyInjectionTests.cs

@@ -1,5 +1,4 @@
-using DIT.Workflower.DependencyInjection.Abstractions;
-using DIT.Workflower.DependencyInjection.Extensions;
+using DIT.Workflower.DependencyInjection.Extensions;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace DIT.Workflower.Tests.DependencyInjection;
@@ -49,7 +48,6 @@ public class DependencyInjectionTests
         Assert.NotNull(v1);
         Assert.NotNull(v2);
 
-
         Assert.Single(v1!.GetAllowedTransitions(PhoneState.Idle));
         Assert.Single(v2!.GetAllowedTransitions(PhoneState.Idle));