How to merge two repositories to one query?

[sturlath]

What I have are two sets of queries (DeviceOne and DeviceTwo) that I like to query like this

{
  DeviceOne
  {
     SomeData(id:"6bc87306-dfd2-4ecb-8ae8-1a96edf4f62e")
     {
        SomeInfo1
      }
   }
  DeviceTwo
  {
     SomethingOtherThanSomeData(id:"75b630a5-3e9c-4e64-a15b-a9b60256a0d1")
     {
        SomeInfo2
     }
   }
}

Then I was trying to merge these two queries here that talk to their separate repositories

public class DeviceOneQuery 
{
    private readonly IDeviceOneRepository repository;

    public DeviceOne(IDeviceOneRepository repository)
    {
        this.repository = repository;
    }

    public async Task<List<SomeInfo1>> SomeData(Guid deviceId)
    {
        return await repository.SomeData(deviceId);
    }
}

and

public class DeviceTwoQuery
{
    private readonly IDeviceTwoRepository repository;

    public DeviceTwo(IDeviceTwoRepository repository)
    {
        this.repository = repository;
    }

    public async Task<List<SomeInfo2>> SomethingOtherThanSomeData(Guid deviceId)
    {
        return await repository.SomethingOtherThanSomeData(deviceId);
    }
}

found out that I can´t add more than one AddQueryType

  _ = services
          .AddScoped<IDeviceOneRepository , DeviceOneRepository >()
          .AddScoped<IDeviceTwoRepository , DeviceTwoRepository >()
          .AddGraphQLServer()
          .AddApolloFederation()
          .AddQueryType<DeviceOneQuery >()
          .AddQueryType<DeviceTwoQuery>()

I get The root type Query has already been registered.

And then I tried to extend the queries (but can I do that or does it need to be the types SomeInfo1 and SomeInfo2 etc?) but failed.

I´m I totally missing the point of here?

[sturlath]

I got help on Slack for getting the queries into one (all methods are now shown) but now I need to figure out how to show them separately under their device types.

  _ = services
          .AddScoped<IDeviceOneRepository , DeviceOneRepository >()
          .AddScoped<IDeviceTwoRepository , DeviceTwoRepository >()
          .AddGraphQLServer()
          .AddApolloFederation()
          .AddQueryType(d => d.Name("Query"))
                .AddTypeExtension<DeviceOneQuery >()
                .AddTypeExtension<DeviceTwoQuery>()

and then on both queries I added [ExtendObjectType("Query")]

with end result like this

[ExtendObjectType("Query")]
public class DeviceOneQuery 
{
    private readonly IDeviceOneRepository repository;

    public DeviceOne(IDeviceOneRepository repository)
    {
        this.repository = repository;
    }

    public async Task<List<SomeInfo1>> SomeData(Guid deviceId)
    {
        return await repository.SomeData(deviceId);
    }
}

Now I just need to figure out how to create this

{
  DeviceOne
  {
      // methods from query one
   }
  DeviceTwo
  {
      // methods from query two
   }
}

[sturlath]

I just created a demo repository with this code

there you can query like this

{
  deviceOne {
    someData(deviceId: "6bc87306-dfd2-4ecb-8ae8-1a96edf4f62e") {
      name
      count
    }
  }
  deviceTwo {
    somethingOtherThanSomeData(deviceId: "75b630a5-3e9c-4e64-a15b-a9b60256a0d1")
    {
      name
      age
    }
  }
}

but there is something missing since I don´t go into the resolvers and this gets returned.

{
  "data": {
    "deviceOne": null,
    "deviceTwo": null
  }
}

Its probably how I´m extending the type. I´m trying other ways to extend it and will report if I figure it out.

This is the code I´m having problem with extending

[ExtendObjectType("Query")]
public class DeviceOneRoot
{
    private readonly IDeviceOneRepository deviceOneRepository;

    public DeviceOneRoot(IDeviceOneRepository deviceOneRepository)
    {
        this.deviceOneRepository = deviceOneRepository;
    }

    public DeviceOne DeviceOne()
    {
        return new DeviceOne(deviceOneRepository);
    }
} 

[sturlath]

Ok the code above now works. What I was missing was to new up some data. But my question now is whether this is correctly setup (or could be done better somehow)

[tobias-tengler]

Something unrelated to your problem, but you should avoid constructor injection in GraphQL types / extensions: https://chillicream.com/docs/hotchocolate/server/dependency-injection/#constructor-injection

Regarding your question: I think having these container types is fine. In our project we also have a "container" type. In our case it just holds onto two Ids and that way we can access these Ids in resolvers below. In your case you could just have two empty placeholder records:

[ExtendObjectType(OperationTypeNames.Query)]
public class DeviceQueryExtensions
{
    public DeviceOne DeviceOne() => new();

    public DeviceTwo DeviceTwo() => new();
}

public record DeviceOne();
public record DeviceTwo();

[ExtendObjectType(typeof(DeviceOne)]
public class DeviceOneExtensions
{
    public string GetData(string id, IDeviceOneRepo repo) => "dummy";
}

[ExtendObjectType(typeof(DeviceTwo)]
public class DeviceTwoExtensions
{
    public string SomeOtherDataOnlyForDeviceTwo(string id, IDeviceTwoRepo repo) => "dummy2";
}

services.AddGraphQLServer()
    .AddQueryType()
    .AddTypeExtension<DeviceQueryExtensions>()
    .AddTypeExtension<DeviceOneExtensions>()
    .AddTypeExtension<DeviceTwoExtensions>()
    .RegisterService<IDeviceOneRepo>(ServiceKind.Synchronized);
    .RegisterService<IDeviceTwoRepo>(ServiceKind.Synchronized);

You could also try to describe your use case for us in an abstract way and we might be able to recommend a better schema design for the use case :)

[sturlath]

Awesome, thank you @tobias-tengler! I have refactored my implementation to mimic yours and I like it far better. And thanks for the DI information. I had already tried that out in another solution but I´m just way to familiar with the constructor injection I just went straight to it.

But yes my use case is somewhat irregular since my data source is Kusto queries through rest API into Azure Data Explorer. And we will have hundreds of different types of devices so we need these "containers" so its easier to find them. The data will be used in a dashboard designer.

One more question about the ServiceKind.Synchronized and the options there (pooled and resolver). What would be the best chose since I´m not using EF as a data source and just going to an API?

[tobias-tengler]

If your services support concurrent access, you can simply omit the ServiceKind and go with the default strategy, which just injects them according to their service lifetime :)