CleanCodeJN.GenericApis 5.1.1

🚀 Generic Web APIs – Fast, Clean, Powerful

Build production-ready APIs instantly – from Minimal APIs and Controllers to fully integrated GraphQL endpoints and an AI-ready MCP Server with CRUD, filtering, sorting & paging – powered by Mediator, AutoMapper, EF Core, FluentValidation, and the IOSP architecture pattern.

⚡ Quickstart

dotnet add package CleanCodeJN.GenericApis

// Program.cs
builder.Services.AddCleanCodeJN<MyDbContext>(options => {...}); // Mandatory: Configure CleanCodeJN options
app.UseCleanCodeJNWithMinimalApis();                            // For REST APIs
app.UseCleanCodeJNWithGraphQL();                                // For autogenerated GraphQL APIs
app.UseCleanCodeJNWithMcp();                                    // For autogenerated MCP Server (AI-callable tools)
app.UseCleanCodeJNWithDocumentation();                          // For autogenerated Command Documentation, visit /docs
                                                                // add <GenerateDocumentationFile>true</GenerateDocumentationFile> to your .csproj file
// Entity
public class Customer : IEntity<int> 
{ 
    public int Id { get; set; } 
    public string Name { get; set; }
}

// DTO
public class CustomerGetDto : IDto 
{ 
    public int Id { get; set; } 
    public string Name { get; set; }
}

// Minimal API
public class CustomersV1Api : IApi
{
    public List<string> Tags => ["Customers Minimal API"];

    public string Route => $"api/v1/Customers";

    public List<Func<WebApplication, RouteHandlerBuilder>> HttpMethods =>
    [
         app => app.MapGet<Customer, CustomerGetDto, int>(
                Route, 
                Tags, 
                where: x => x.Name.StartsWith("a"),
                select: x => new Customer { Name = x.Name }),
    ];
}

// IOSP Workflow
public class YourIntegrationCommand(ICommandExecutionContext executionContext)
    : IntegrationCommand<YourIntegrationRequest, Customer>(executionContext)
{
    public override async Task<BaseResponse<Customer>> Handle(YourIntegrationRequest request, CancellationToken cancellationToken) =>
        await ExecutionContext
            .DoSomethingRequest1()
            .DoSomethingRequest2()
            .DoSomethingRequest3()
            .Execute<Customer>(cancellationToken);
}

Table of Contents

• 🚀 Generic Web APIs – Fast, Clean, Powerful
  • What is in this package
  • 🧪 What is IOSP?
  • ✨ Features at a Glance
  • How to use
• Step by step explanation
  • Add AddCleanCodeJN<IDataContext>() to your Program.cs
  • These are the CleanCodeJN Options
  • Add app.UseCleanCodeJNWithMinimalApis() when using Minimal APIs to your Program.cs
  • Add app.UseCleanCodeJNWithGraphQL() when using automatic GraphQL to your Program.cs
  • Add app.UseCleanCodeJNDocumentation() when using automatic Command documentation (from your XML comments) to your Program.cs
  • 🤖 Add app.UseCleanCodeJNWithMcp() to expose your API as an AI-callable MCP Server
  • When using Controllers add this to your Program.cs
  • Start writing Minimal Apis by implementing IApi
  • Extend standard CRUD operations by specific Where(), Include() or Select() clauses
  • Use ApiCrudControllerBase for CRUD operations in controllers
  • You can also override your Where, Include or Select clauses
  • For using the /filtered api with a filter, just provide a serialized json as filter parameter
  • The Type can be specified with these values
• Advanced Topics
  • Built-in Support for Fluent Validation
  • Implement your own specific Request
  • Requests can also be marked as ICachableRequest, which uses IDistributedCache to cache the Response
  • With your own specific Command using CleanCodeJN.Repository
  • Custom Middlewares
  • Use IOSP for complex business logic
    • Derive from BaseIntegrationCommand
    • Write Extensions on ICommandExecutionContext with Built in Requests or with your own
    • Use WithParallelWhenAllRequests() to execute multiple requests in parallel and execute when all tasks are finished
    • Use GetListParallelWhenAll() to get all results of WithParallelWhenAllRequests
    • Use GetParallelWhenAllByIndex<T> to get the result of the WithParallelWhenAllRequests with a typed object by index
    • Use IfRequest() to execute an optional request - continue when conditions are not satisfied
    • Use IfBreakRequest() to execute an optional request - break whole process when conditions are not satisfied
    • See the how clean your code will look like in the end
• Sample Code

This package gives you:

• ✅ blazing-fast setup
• ✅ CRUD APIs in seconds without writing a single line of code
• ✅ GraphQL Support with automatic schema generation from your Entities and DTOs
• ✅ complex business logic with IOSP
• ✅ automatic command and workflow documentation by using your xml comments - visit /docs
• ✅ AI-ready MCP Server – one line turns your entire API into AI-callable tools
• ✅ testable architecture
• ✅ maintainable and modular code

🧪 What is IOSP?

Integration Operation Segregation Principle
Split your request handlers into: Operations → contain real logic (DB, API, etc.)
Integrations → just orchestrate other request handlers

✨ Features at a Glance

• ⚡ Plug & Play CRUD APIs (Minimal API or Controller-based)
• 🧬 Auto-generated GraphQL API with query/mutation/filter/sort/projection support via HotChocolate
• 🤖 Auto-generated MCP Server — every CRUD endpoint becomes an AI-callable tool instantly
• 📦 Built-in paging, filtering & projections
• 🧠 Clean separation of logic using the Mediator pattern
• 🧱 Entity Framework abstraction via DataRepositories
• 🔀 Auto-mapping of Entities ⇄ DTOs (no config needed)
• 🧪 Fluent validation out of the box
• 🧼 CleanCode-first architecture using the IOSP Principle
• 🧪 Easily mockable and testable
• 🚀 Runs on .NET 10

How to use

• Add AddCleanCodeJN<IDataContext>() to your Program.cs
• Add app.UseCleanCodeJNWithMinimalApis() to your Program.cs for minimal APIs or use AddControllers + MapControllers()
• Add app.UseCleanCodeJNWithGraphQL() to your Program.cs for GraphQL support
• Add app.UseCleanCodeJNWithMcp() to your Program.cs to expose your API as an MCP Server
• Start writing Apis by implementing IApi
• Extend standard CRUD operations by specific Where() and Include() clauses
• Use IOSP for complex business logic

Step by step explanation

Add AddCleanCodeJN<IDataContext>() to your Program.cs

builder.Services.AddCleanCodeJN<MyDbContext>(options => {});

• All Entity ⇔ DTO Mappings will be done automatically if the naming Convention will be applied: e.g.: Customer ⇔ CustomerGetDto.
• DTO has to start with Entity-Name and must inherits from IDto
• Entity must inherit from IEntity

These are the CleanCodeJN Options

/// <summary>
/// The options for the CleanCodeJN.GenericApis
/// </summary>
public class CleanCodeOptions
{
    /// <summary>
    /// The assemblies that contain the command types, Entity types and DTO types for automatic registration of commands, DTOs and entities.
    /// </summary>
    public List<Assembly> ApplicationAssemblies { get; set; } = [];

    /// <summary>
    /// The assembly that contains the validators types for using Fluent Validation.
    /// </summary>
    public Assembly ValidatorAssembly { get; set; }

    /// <summary>
    /// The assembly that contains the automapper mapping profiles.
    /// </summary>
    public Action<IMapperConfigurationExpression> MappingOverrides { get; set; }

    /// <summary>
    /// If true: Use distributed memory cache. If false: you can add another Distributed Cache implementation.
    /// </summary>
    public bool UseDistributedMemoryCache { get; set; } = true;

    /// <summary>
    /// If true: Add default logging behavior. If false: you can add another logging behavior.
    /// </summary>
    public bool AddDefaultLoggingBehavior { get; set; }

    /// <summary>
    /// Mediatr Types of Open Behaviors to register
    /// </summary>
    public List<Type> OpenBehaviors { get; set; } = [];

    /// <summary>
    /// Mediatr Types of Closed Behaviors to register
    /// </summary>
    public List<Type> ClosedBehaviors { get; set; } = [];
    
    /// <summary>
    /// Gets or sets a value indicating whether GraphQL auto-wiring is enabled.
    /// </summary>
    public GraphQLOptions GraphQLOptions { get; set; }
}

Add app.UseCleanCodeJNWithMinimalApis() when using Minimal APIs to your Program.cs

app.UseCleanCodeJNWithMinimalApis();

Add app.UseCleanCodeJNWithGraphQL() when using automatic GraphQL to your Program.cs

app.UseCleanCodeJNWithGraphQL();

Add app.UseCleanCodeJNDocumentation() when using automatic Command documentation (from your XML comments) to your Program.cs

app.UseCleanCodeJNDocumentation();  // add <GenerateDocumentationFile>true</GenerateDocumentationFile> to your .csproj file

🤖 Add app.UseCleanCodeJNWithMcp() to expose your API as an AI-callable MCP Server

One line of code turns your entire API into a Model Context Protocol (MCP) Server — discoverable and executable by any AI assistant that supports the standard MCP Streamable HTTP transport (Claude, Cursor, Continue, and more).

app.UseCleanCodeJNWithMcp();

This registers a POST /mcp endpoint implementing the MCP Streamable HTTP transport (protocol version 2024-11-05). No custom protocol, no vendor lock-in — any standard MCP client works out of the box.

What gets auto-generated?

CRUD tools are generated automatically from your Controllers and Minimal APIs — including full JSON schemas derived from your DTOs:

Custom endpoint tools are generated from any Minimal API endpoint annotated with .WithSummary() / .WithDescription():

public List<Func<WebApplication, RouteHandlerBuilder>> HttpMethods =>
[
    // Standard CRUD → auto-discovered, no annotation needed
    app => app.MapGet<Customer, CustomerGetDto, int>(Route, Tags),
    app => app.MapPost<Customer, CustomerPostDto, CustomerGetDto>(Route, Tags),

    // Custom endpoints → annotate to expose as MCP tools
    app => app.MapGetRequest(Route + "/cached", Tags, async ([FromServices] ApiBase api) =>
            await api.Handle<Customer, List<CustomerGetDto>>(new CachedCustomerRequest()))
        .WithSummary("Get cached customers")
        .WithDescription("Returns a cached list of customers. Served from cache if available."),

    app => app.MapDeleteRequest<Customer, CustomerGetDto, int>(Route, Tags, id => new DeleteCustomerIntegrationRequest { Id = id })
        .WithSummary("Delete customer via integration flow")
        .WithDescription("Deletes a customer using the full integration delete workflow."),
];

Enrich tool schemas with DTO XML comments

Add /// <summary> comments to your DTO properties — the MCP server reads them automatically and includes them as description fields in the JSON schema. This tells the AI assistant exactly what each field means, including constraints and examples.

Step 1: Enable XML doc generation in your DTO project's .csproj:

<PropertyGroup>
  <GenerateDocumentationFile>true</GenerateDocumentationFile>
</PropertyGroup>

Step 2: Add XML comments to your DTO properties:

public class CustomerPostDto : IDto
{
    /// <summary>Full name of the customer, e.g. 'Acme Corp'. Maximum 100 characters.</summary>
    public string Name { get; set; }
}

public class CustomerPutDto : IDto
{
    /// <summary>Unique identifier of the customer to update.</summary>
    public int Id { get; set; }

    /// <summary>New full name of the customer, e.g. 'Acme Corp'. Maximum 100 characters.</summary>
    public string Name { get; set; }
}

The MCP tool schema for create_customer will then look like:

{
  "name": "create_customer",
  "inputSchema": {
    "properties": {
      "name": {
        "type": "string",
        "description": "Full name of the customer, e.g. 'Acme Corp'. Maximum 100 characters."
      }
    }
  }
}

This enables AI assistants to ask the right questions when creating or updating records — e.g. "What is the customer's full name?" — before sending the request.

IOSP Command tools are generated from your XML documentation — giving AI assistants insight into your business workflows:

/// <summary>Handles the deletion of a customer including all related data.</summary>
/// <remarks>Executes in parallel: retrieves customer, validates invoices, then deletes.</remarks>
public class DeleteCustomerIntegrationCommand(...) : IntegrationCommand<...> { }

All tool calls go through the standard HTTP pipeline — your authentication and authorization middleware applies automatically.

Connect any MCP client

Claude Desktop (claude_desktop_config.json):

{
  "mcpServers": {
    "my-api": {
      "url": "https://your-api.com/mcp"
    }
  }
}

Cursor (.cursor/mcp.json):

{
  "mcpServers": {
    "my-api": {
      "url": "https://your-api.com/mcp"
    }
  }
}

Once connected, your AI assistant knows your full API surface and can answer "what can you do with customers?" or execute "create a customer named Acme Corp" directly.

When using Controllers add this to your Program.cs

builder.Services.AddControllers()
    .AddNewtonsoftJson(); // this is needed for "http patch" only. If you do not need to use patch, you can remove this line

// After Build()
app.MapControllers();

When using GraphQL add this to your Program.cs

builder.Services.AddCleanCodeJN<MyDbContext>(options =>
{
    options.ApplicationAssemblies =
    [
        typeof(CleanCodeJN.GenericApis.Sample.Business.AssemblyRegistration).Assembly,
        typeof(CleanCodeJN.GenericApis.Sample.Core.AssemblyRegistration).Assembly,
        typeof(CleanCodeJN.GenericApis.Sample.Domain.AssemblyRegistration).Assembly
    ];
    options.ValidatorAssembly = typeof(CleanCodeJN.GenericApis.Sample.Core.AssemblyRegistration).Assembly;

    // Enable GraphQL with all CRUD operations
    options.GraphQLOptions = new GraphQLOptions
    {
        Get = true,
        Create = true,
        Update = true,
        Delete = true,
        AddAuthorizationWithPolicyName = "MyPolicy", // optional for adding authorization policy
    };
});

// Optional: Add Authentication and Authorization if needed
builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("MyPolicy", policy =>
    {
        policy.RequireAuthenticatedUser();
        policy.RequireClaim("role", "admin");
    });
});

Start writing Minimal Apis by implementing IApi

public class CustomersV1Api : IApi
{
    public List<string> Tags => ["Customers Minimal API"];

    public string Route => $"api/v1/Customers";

    public List<Func<WebApplication, RouteHandlerBuilder>> HttpMethods =>
    [
        app => app.MapGet<Customer, CustomerGetDto, int>(
            Route,
            Tags,
            where: x => x.Name.StartsWith("Customer"),
            includes: [x => x.Invoices],
            select: x => new Customer { Name = x.Name },
            ignoreQueryFilters: true),

        app => app.MapGetPaged<Customer, CustomerGetDto, int>(Route, Tags),

        app => app.MapGetFiltered<Customer, CustomerGetDto, int>(Route, Tags),

        app => app.MapGetById<Customer, CustomerGetDto, int>(Route, Tags),

        app => app.MapPut<Customer, CustomerPutDto, CustomerGetDto>(Route, Tags),

        app => app.MapPost<Customer, CustomerPostDto, CustomerGetDto>(Route, Tags),

        app => app.MapPatch<Customer, CustomerGetDto, int>(Route, Tags),

        // Or use a custom Command with MapDeleteRequest()
        app => app.MapDeleteRequest<Customer, CustomerGetDto, int>(Route, Tags, id => new DeleteCustomerIntegrationRequest { Id = id })
    ];
}

Extend standard CRUD operations by specific Where(), Include() or Select() clauses

public class CustomersV1Api : IApi
{
    public List<string> Tags => ["Customers Minimal API"];

    public string Route => $"api/v1/Customers";

    public List<Func<WebApplication, RouteHandlerBuilder>> HttpMethods =>
    [
         app => app.MapGet<Customer, CustomerGetDto, int>(Route, Tags, where: x => x.Name.StartsWith("a"), select: x => new Customer { Name = x.Name }),
    ];
}

Use ApiCrudControllerBase for CRUD operations in controllers

[Tags("Customers Controller based")]
[Route($"api/v2/[controller]")]

public class CustomersController(IMediator commandBus, IMapper mapper)
    : ApiCrudControllerBase<Customer, CustomerGetDto, CustomerPostDto, CustomerPutDto, int>(commandBus, mapper)
{
}

You can also override your Where, Include or Select clauses

/// <summary>
/// Customers Controller based
/// </summary>
/// <param name="commandBus">IMediatr instance.</param>
/// <param name="mapper">Automapper instance.</param>
[Tags("Customers Controller based")]
[Route($"api/v2/[controller]")]
public class CustomersController(IMediator commandBus, IMapper mapper)
    : ApiCrudControllerBase<Customer, CustomerGetDto, CustomerPostDto, CustomerPutDto, int>(commandBus, mapper)
{
    /// <summary>
    /// Where clause for the Get method.
    /// </summary>
    public override Expression<Func<Customer, bool>> GetWhere => x => x.Name.StartsWith("Customer");

    /// <summary>
    /// Includes for the Get method.
    /// </summary>
    public override List<Expression<Func<Customer, object>>> GetIncludes => [x => x.Invoices];

    /// <summary>
    /// Select for the Get method.
    /// </summary>
    public override Expression<Func<Customer, Customer>> GetSelect => x => new Customer { Id = x.Id, Name = x.Name };

    /// <summary>
    /// AsNoTracking for the Get method.
    /// </summary>
    public override bool AsNoTracking => true;
}

For using the /filtered api with a filter, just provide a serialized json as filter parameter, like this:

{
    "Condition" : 0, // 0 = AND; 1 = OR
    "Filters": [
        {
            "Field": "Name",
            "Value": "aac",
            "Type": 0
        },
        {
            "Field": "Id",
            "Value": "3",
            "Type": 1
        }
    ]
}

Which means: Give me all Names which CONTAINS "aac" AND have Id EQUALS 3. So string Types use always CONTAINS and integer types use EQUALS. All filters are combined with ANDs.

The Type can be specified with these values

public enum FilterTypeEnum
{
    STRING = 0,
    INTEGER = 1,
    DOUBLE = 2,
    INTEGER_NULLABLE = 3,
    DOUBLE_NULLABLE = 4,
    DATETIME = 5,
    DATETIME_NULLABLE = 6,
    GUID = 7,
    GUID_NULLABLE = 8,
}

Advanced Topics

Built-in Support for Fluent Validation:

Just write your AbstractValidators<T>. They will be automatically executed on generic POST and generic PUT actions:

public class CustomerPostDtoValidator : AbstractValidator<CustomerPostDto>
{
    public CustomerPostDtoValidator()
    {
        RuleFor(x => x.Name)
            .NotEmpty()
            .MaximumLength(10);
    }

public class CustomerPutDtoValidator : AbstractValidator<CustomerPutDto>
{
    public CustomerPutDtoValidator()
    {
        RuleFor(x => x.Id)
            .GreaterThan(0);

        RuleFor(x => x.Name)
            .NotEmpty()
            .MaximumLength(10)
            .CreditCard();
    }
}

Implement your own specific Request:

public class SpecificDeleteRequest : IRequest<BaseResponse<Customer>>
{
    public required int Id { get; init; }
}

Requests can also be marked as ICachableRequest, which uses IDistributedCache to cache the Response:

public class SpecificDeleteRequest : IRequest<BaseResponse<Customer>>, ICachableRequest
{
    public required int Id { get; init; }

    public bool BypassCache { get; }

    public string CacheKey => "Your Key";

    public TimeSpan? CacheDuration => TimeSpan.FromHours(168);
}

With your own specific Command using CleanCodeJN.Repository

public class SpecificDeleteCommand(IRepository<Customer, int> repository) : IRequestHandler<SpecificDeleteRequest, BaseResponse<Customer>>
{
    public async Task<BaseResponse<Customer>> Handle(SpecificDeleteRequest request, CancellationToken cancellationToken)
    {
        var deletedCustomer = await repository.Delete(request.Id, cancellationToken);

        return await BaseResponse<Customer>.Create(deletedCustomer is not null, deletedCustomer);
    }
}

Custom Middlewares

CleanCodeJN.GenericApis is fully compatible with the standard ASP.NET Core middleware pipeline.
You can easily add custom middlewares for authentication, logging, exception handling, or any other cross-cutting concern — before or after the CleanCodeJN setup.

Where to Add Middlewares

Custom middlewares should be registered in your Program.cs after the AddCleanCodeJN() call, but before the CleanCodeJN middlewares such as UseCleanCodeJNWith. Global mediator behaviours for logging or caching can directly be added in the AddCleanCodeJN() options.

There already is a default logging behaviour included, which can be enabled in the options. This behaviour logs the execution and exection time of each command.

Example Structure

var builder = WebApplication.CreateBuilder(args);

// Add CleanCodeJN
builder.Services.AddCleanCodeJN<MyDbContext>(options =>
{
    options.AddDefaultLoggingBehavior = true; // Enables default logging behaviour
    options.OpenBehaviors = [typeof(CustomBehavior<,>)]; // Adds custom behaviour with 2 generic parameters for TRequest, TResponse

    options.ApplicationAssemblies = [typeof(Program).Assembly];
    options.ValidatorAssembly = typeof(Program).Assembly;
});

// Add custom services
builder.Services.AddLogging();
builder.Services.AddAuthentication("Bearer")
    .AddJwtBearer("Bearer", options =>
    {
        options.Authority = "https://your-keycloak-domain/auth/realms/yourrealm";
        options.Audience = "your-api";
    });
builder.Services.AddAuthorization();

var app = builder.Build();

// Add your middlewares in the right order

// Authentication & Authorization
app.UseAuthentication();
app.UseAuthorization();

// Custom Logging Middleware
app.Use(async (context, next) =>
{
    var logger = context.RequestServices.GetRequiredService<ILogger<Program>>();
    logger.LogInformation("➡️ Request: {Method} {Path}", context.Request.Method, context.Request.Path);
    await next();
    logger.LogInformation("⬅️ Response: {StatusCode}", context.Response.StatusCode);
});

// Global Exception Handling
app.Use(async (context, next) =>
{
    try
    {
        await next();
    }
    catch (Exception ex)
    {
        var logger = context.RequestServices.GetRequiredService<ILogger<Program>>();
        logger.LogError(ex, "Unhandled exception occurred");

        context.Response.StatusCode = 500;
        await context.Response.WriteAsJsonAsync(new
        {
            Title = "Unexpected Error",
            Detail = ex.Message
        });
    }
});

// CleanCodeJN Middlewares
app.UseCleanCodeJNWithMinimalApis();
app.UseCleanCodeJNWithGraphQL();
app.UseCleanCodeJNWithMcp();
app.UseCleanCodeJNDocumentation();

// Run
app.Run();

Use IOSP for complex business logic

Derive from BaseIntegrationCommand:

public class YourIntegrationCommand(ICommandExecutionContext executionContext)
    : IntegrationCommand<YourIntegrationRequest, YourDomainObject>(executionContext)

Write Extensions on ICommandExecutionContext with Built in Requests or with your own

public static ICommandExecutionContext CustomerGetByIdRequest(
    this ICommandExecutionContext executionContext, int customerId) 
    => executionContext.WithRequest(
            () => new GetByIdRequest<Customer>
            {
                Id = customerId,
                Includes = [x => x.Invoices, x => x.OtherDependentTable],
            },
            CommandConstants.CustomerGetById);

Use WithParallelWhenAllRequests() to execute multiple requests in parallel and execute when all tasks are finished:

   executionContext.WithParallelWhenAllRequests(
                [
                    () => new GetByIdRequest<Customer, int>
                          {
                              Id = request.Id,
                          },
                    () => new GetByIdRequest<Customer, int>
                          {
                              Id = request.Id,
                          },
                ])

Use GetListParallelWhenAll() to get all results of WithParallelWhenAllRequests():

   .WithRequest(
                () => new YourSpecificRequest
                {
                    Results = executionContext.GetListParallelWhenAll("Parallel Block"),
                })

Use GetParallelWhenAllByIndex<T>() to get the result of the WithParallelWhenAllRequests() with a typed object by index:

   .WithRequest(
                () => new GetByIdRequest<Invoice, Guid>
                {
                    Id = executionContext.GetParallelWhenAllByIndex<Invoice>("Parallel Block", 1).Id,
                })

Use IfRequest() to execute an optional request - continue when conditions are not satisfied:

    executionContext.IfRequest(() => new GetByIdRequest<Customer, int> { Id = request.Id },
                               ifBeforePredicate: () => true,
                               ifAfterPredicate: response => response.Succeeded)

Use IfBreakRequest() to execute an optional request - break whole process when conditions are not satisfied:

    executionContext.IfBreakRequest(() => new GetByIdRequest<Customer, int> { Id = request.Id },
                                    ifBeforePredicate: () => true,
                                    ifAfterPredicate: response => response.Succeeded)

This is how clean your code will look like in the end

public class YourIntegrationCommand(ICommandExecutionContext executionContext)
    : IntegrationCommand<YourIntegrationRequest, Customer>(executionContext)
{
    public override async Task<BaseResponse<Customer>> Handle(YourIntegrationRequest request, CancellationToken cancellationToken) =>
        await ExecutionContext
            .CandidateGetByIdRequest(request.Dto.CandidateId)
            .CustomerGetByIdRequest(request.Dto.CustomerIds)
            .GetOtherStuffRequest(request.Dto.XYZType)
            .PostSomethingRequest(request.Dto)
            .SendMailRequest()
            .Execute<Customer>(cancellationToken);
}

Sample Code

GitHub Full Sample