Automatic DataLoader-free resolver mapping via OfX integration

[quyvu01]

Problem

Writing DataLoaders manually for every entity in HotChocolate
is repetitive and error-prone. For microservices with 10+ entities,
this becomes a significant maintenance burden.

Proposed approach (solution)

// GraphQL response type with chained dependencies
public class MemberResponse
{
    public string Id { get; set; }
    public string UserId { get; set; }

    // First dependency: Fetch ProvinceId from User service
    [UserOf(nameof(UserId), Expression = "ProvinceId")]
    public string ProvinceId { get; set; }

    // Second dependency: Fetch CountryName from Province service
    // OfX automatically resolves ProvinceId first, then uses it here
    [ProvinceOf(nameof(ProvinceId), Expression = "Country.Name")]
    public string CountryName { get; set; }
}

// Sample GraphQl query
public class Query
{
    public List<MemberResponse> GetMembers([Parameters] GetMembersParameters parameters)
    {
        // Just return your data - OfX handles everything!
        return
        [
            new MemberResponse
            {
                Id = "member-1",
                UserId = "user-1"
            },
            new MemberResponse
            {
                Id = "member-2",
                UserId = "user-2"
            })
        ];
    }
}

// Configuration for OfX-HotChocolate
using OfX;
using HotChocolate;

var builder = WebApplication.CreateBuilder(args);

// 1. Configure HotChocolate GraphQL Server
var registerBuilder = builder.Services.AddGraphQLServer()
    .AddQueryType<Query>()
    .AddType<MembersType>();

// 2. Configure OfX with HotChocolate integration
builder.Services.AddOfX(cfg =>
{
    cfg.AddAttributesContainNamespaces(typeof(IKernelAssemblyMarker).Assembly);
    cfg.AddModelConfigurationsFromNamespaceContaining<IAssemblyMarker>();
    cfg.AddGrpcClients(c =>
        c.AddGrpcHosts("http://localhost:5001", "http://localhost:5002", "http://localhost:5003"));
})
.AddOfXEFCore(cfg => cfg.AddDbContexts(typeof(DbContext1), typeof(DbContext2)))
.AddHotChocolate(cfg => cfg.AddRequestExecutorBuilder(registerBuilder));

...

With sample request

{
  members {
    id
    countryName
  }
}

OfX flow

// OfX automatically:
// 1. Fetches ProvinceId
//    from User service
// 2. Uses ProvinceId to fetch
//    Country.Name from
//    Province service
// 3. Returns only countryName
//    to GraphQL client

{
  "data": {
    "members": [
      {
        "id": "member-1",
        "countryName": "Canada"
      },
      {
        "id": "member-2",
        "countryName": "United States"
      }
    ]
  }
}

What OfX brings to HotChocolate

• Auto-batching (N+1 solved declaratively)
• Ordered dependency resolution
• Transport-agnostic (gRPC, Kafka, NATS...)
• Roslyn Analyzer for compile-time validation
• Expression Language for complex queries

Integration

OfX-HotChocolate package already exists as proof of concept:
https://ofxmapper.net/docs/integrations/hotchocolate/