Sorting a result collection.

[melishatrout2]

Let's say I have the following schema:

type Query {
 searchSoil(soilId: [ID!]! ): Soil
}

type Soil {
 soilId: ID!
 soilMix: String
 plant: [Plant]
}

type Plant {
 plantId: ID!
 soilId: ID!
 commonName: String
}

and the following class:

@DgsComponent
public class SoilDataFetcher {
    @DgsQuery
    public CompletableFuture<DataFetcherResult<Connection<Soil>>> searchSoilByIds(@NonNull @InputArgument("soilId") List<UUID> soilId, DgsDataFetchingEnvironment dfe) {
        DataLoader<List<UUID>, List<Soil>> soilRetriever = dfe.getDataLoader(SoilDataLoaderByIds.class);
        return soilRetriever.load(soilId)
                .thenApply((soils) -> DataFetcherResult.<Connection<Soil>>newResult()
                        .data(new SimpleListConnection<>(soils).get(dfe))
                        .localContext(new PlantContext(soils.stream().map(Soil::getSoilId)))
                        .build());
    }

    @DgsData(parentType = "Soil")
    public CompletableFuture<List<Plant>> plants(DgsDataFetchingEnvironment dfe) {
        PlantContext context = dfe.getLocalContext();
        DataLoader<List<String>, List<Plant>> loader = dfe.getDataLoader(PlantDataLoader.class);
        return loader.load(context);
    }
}

Both soil and plant data are retrieve by two separate API. Is there a way of sorting the soil list by plant commonName before sending the data back to the client?

[paulbakker]

I'm not aware of a great way of doing this - the problem is that there isn't really a "callback" to run code after the plants field datafetcher completed.

A workaround is to not have a separate datafetcher for plants, but resolve everything in the "root" searchSoilByIds datafetcher.

1. Use getSelectionSet on the DataFetchingEnvironment to find out if the plants field is requested. (see https://netflix.github.io/dgs/advanced/context-passing/#pre-loading)
2. Load soils, and in the same method, also load plants.
3. Merge the soils and plants in the data structure you want to return, including the sorting.