Design for MongoDB generic resolver

[BaptisteGi]

Hello!

I have a setup with Hot-chocolate and MongoDB. This is a sample of my database schema:

Basically every entity is stored as a separate document. Reference to "parent" entity is directly stored in the document (e.g. in contact document there is a "accountID" field containing the linked account identifier).

Here I can run this kind of GraphQL query:

query {
  accounts {
    name
    contacts {
      name
    }
    orders {
      name
    }
  }
}

On server side I have a "AccountResolvers" class that resolves orders and contacts relationships:

[ExtendObjectType(typeof(Account))]
public class AccountResolvers
{
    public IExecutable<Contact> GetContacts([Service] IMongoCollection<Contact> collection, [Parent] Account @account)
            => collection.Find(ctc => ctc.AccountID == @account.ID).AsExecutable();

    public IExecutable<Order> GetOrders([Service] IMongoCollection<Order> collection, [Parent] Account @account)
            => collection.Find(ord => ord.AccountID == @account.ID).AsExecutable();
}

The concern I have so far is that I'm introducing a lot of boilerplate code (only types are different).

That being said, I tried to create a generic resolver:

private class GenericResolvers<TTarget, TSource>
{
    public IExecutable<TTarget> ResolveList([Service] IMongoCollection<TTarget> collection, [Parent] TSource @parentObject, string foreignKey)
    {
        //Get the parent object ID
        string id = @parentObject.GetType().GetField("ID").ToString();

        //Build the filter
        var builder = Builders<TTarget>.Filter;
        var filter = builder.Eq(foreignKey, id);

        //Return the filtered collection
        return collection.Find(filter).AsExecutable();
    }
}

Then tried to attach it to fields using "ObjectFieldDescriptorAttribute" (I kinda like the "annotation-based" approach).

// !! THIS CODE IS NOT WORKING !!
public class GenericResolverMiddlewareAttribute <TTarget, TSource> : ObjectFieldDescriptorAttribute // <- C# is not supporting generic attributes
{
    public string _foreignKey { get; set; }

    public GenericResolverMiddlewareAttribute(string foreignKey)
    {
        _foreignKey = foreignKey;
    }

    public override void OnConfigure(IDescriptorContext context, IObjectFieldDescriptor descriptor, MemberInfo member)
    {
        descriptor.ResolveWith<GenericResolvers<TTarget, TSource>>(r => r.ResolveList(default!, default!, default!)).Argument("foreignKey", _ => _.DefaultValue(foreignKey));
    }
}

// !! THIS CODE IS NOT WORKING !!
public class Account
{
    public string ID { get; set; }
    public string Name { get; set; }

    [GenericResolverMiddleware<Contact, Account>("AccountID")] // <- C# is not supporting generic attributes
    public IExecutable<Contact> Contacts { get; set; }
}

At the end the syntax is not the most elegant I've ever seen (might probably be improved) but it would allow me to define everything at model level and then get rid of all the boilerplate resolver code. It was without counting on the fact that C# is not supporting generic attributes and it seems that it won't change anytime soon... C# compiler roadmap

I'm a bit in a dead end with my design here. I'm currently having a look on how default resolver works with hot-chocolate (maybe find a way to make it fits with my setup), also having a look on projection... I have two constraints: first is that I can't really change database structure, second is that I would like to keep schema changes (adding new entity, new field) as simple as possible (just some lines in the model would be the best) to have something which is more a configuration task rather than some development.

Would like to check with you if there is any viable workaround to this C# limitation? If some of you found a different answer to this generic resolver question? Suggestions are welcome!

Thanks! ✌️