How to access root DgsDataFetchingEnvironment.getSource() from a deep nested data fetcher

[driptaroop]

I was following the documentation on getting the id from the source of the DgsDataFetchingEnvironment.

This is my graphql schema:

type Query {
    getCustomerDetail(customerId: ID!): Customer
    getAllCustomerDetails: [Customer]!
}

type Customer {
    id: ID!
    name: CustomerName!
    dob: Date!
    age: Int!
    contact: Contact!
    maritalStatus: MaritalStatus
    jobStatus: JobStatus
    citizenship: String!
    taxNumber: String!
}

scalar Date

enum JobStatus {
    EMPLOYED, KURZARBEIT, RETIRED
}

enum MaritalStatus {
    MARRIED, SINGLE, WIDOWED
}

type Contact {
    email: String!
    address: Address!
    phones: [Phone!]!
}

type Phone {
    callNumber: String!
    extension: String
}

type Address {
    street: String!
    number: String!
    additional: String
    pincode: String!
    city: String!
    country: String!
}

type CustomerName {
    firstName: String!
    lastName: String!
    salutation: String
}

This is my data fetcher body:

    @DgsData(parentType = DgsConstants.QUERY_TYPE, field = DgsConstants.QUERY.GetCustomerDetail)
    fun findCustomer(@InputArgument("customerId") customerId: String): Customer {
        return customerService.find(customerId)?.let(customerMapper) ?: throw IllegalStateException("no customer found")
    }

    @DgsData(parentType = DgsConstants.QUERY_TYPE, field = DgsConstants.QUERY.GetAllCustomerDetails)
    fun getAllCustomers(): List<Customer> = customerService.getAllCustomers().map(customerMapper)

    @DgsData(parentType = DgsConstants.CUSTOMER.TYPE_NAME, field = DgsConstants.CUSTOMER.Contact)
    fun getContact(dfe: DgsDataFetchingEnvironment): Contact {
        val customer: Customer = dfe.getSource()
        return ContactInternal(
            customerId = customer.id,
            email = emailService.getEmail(customer.id)?.email
        )
    }

    @DgsData(parentType = DgsConstants.CUSTOMER.TYPE_NAME, field = DgsConstants.CUSTOMER.Name)
    fun getCustomerName(dfe: DataFetchingEnvironment): CustomerName {
        val customer: Customer = dfe.getSource()
        return customer.name
    }

    @DgsData(parentType = DgsConstants.CONTACT.TYPE_NAME, field = DgsConstants.CONTACT.Address)
    fun getAddress(dfe: DgsDataFetchingEnvironment): Address {
        val contact: ContactInternal = dfe.getSource()
        return addressService.getAddress(contact.customerId)?.let(addressMapper) ?: throw IllegalStateException("no address found")
    }

    @DgsData(parentType = DgsConstants.CONTACT.TYPE_NAME, field = DgsConstants.CONTACT.Phones)
    fun phones(dfe: DgsDataFetchingEnvironment): List<Phone> {
        val contact: ContactInternal = dfe.getSource()
        return phoneService.getPhones(contact.customerId)?.map(phoneMapper) ?: throw IllegalStateException("no phone found")
    }

As you can see, the contact data fetcher(getContact method) has no problem accessing the source type Customer and can extract the id out of it. But if I go one level deeper, the address data fetcher (getAddress method) cannot access the root source of Customer, but can only access parent level (Contact).

Since contact does not have the customer Id, I had to create a ContactInternal which contains the customerId to make it work.

class ContactInternal(
    val customerId: String,
    email: String?,
    address: Address? = null,
    phones: List<Phone>? = null
) : Contact(email, address, phones)

Is this the right way to do it? or is there anyway to access the root level source from deep nested fetchers?

[paulbakker]

We recently added docs that explain the different options for dealing with this: https://netflix.github.io/dgs/advanced/context-passing/

[driptaroop]

I am talking about this document only (see my link at the first line). I checked out the documentation and it worked wonderfully for shallow nested structures. but for deep nested structures I had to make a new internal pojo class for every level of depth to pass down the ID. I am asking whether there is a way to access the root level source from any level of nest.

[srinivasankavitha]

You can also use a custom context to pass down the relevant information down to any level.
Check out the docs for that here:
https://netflix.github.io/dgs/advanced/custom-datafetcher-context/

EDIT: Actually, this approach is not recommended for passing down context specific to the data fetchers, since the dgs custom context will be shared across fetchers owing there being just one instance of it. Using the local context is better to avoid clashes as @paulbakker describes below.

[paulbakker]

There is no way to use getSource for this scenario. I think your best option is to use a DataFetcherResult with localContext, which is one of the other options described in the docs. The localContext keeps getting passed down (until you explicitly clear/change it), so you can put the id on there so it can be retrieved in the nested datafetchers.

[driptaroop]

Thank you both @srinivasankavitha and @paulbakker . I feel there are some nitty-gritties I still don't completely get. Let me try to explain it in a bit more detail.

If you see my data fetcher class in the post, findCustomer and getAllCustomers all share the other nested data fetchers (address, phone etc).

In the findCustomer data fetcher, I can put a single customer id in the local context. But in the getAllCustomers data fetcher, I have to put a collection of customer Id in the local context. Now, from the shared nested data fetchers, when I get the local context, I can either get a single customer Id or a collection of customer ids.

To work with this, I can check the type each time I get the localcontext in the nested data fetcher and depending on whether I get single id/collection of ids, I can decide on how to fetch the data. I feel that it is already a bit verbose and if there are lot of common nested data fetchers with other queries, there have to be a lot of type check for local context in the nested data fetchers.

What I wanted to understand is if this is the right way to do things. Is there anyway to get only the customer for which the nested data fetcher is called? in that case, the deep nested data fetchers doesn't have to be concerned about the localcontext types.