How to prevent caching the Union resolved type

[janko]

Our application is retrieving information about tenants in buildings, and one type of data are reservations for certain parts of buildings. For the current tenant, we retrieve all reservations, using Reservation type for reservation owned by the current tenant, and AnonymousReservation for reservations owned by other tenants. We use a union for this:

class ReservationUnion < BaseUnion
  possible_types ReservationType, AnonymousReservationType

  def self.resolve_type(object, context)
    if object.tenant_id == context[:current_tenant]&.id
      ReservationType
    else
      AnonymousReservationType
    end
  end
end

class TenantType < BaseObject
  field :reservations, Unions::ReservationUnion.connection_type

  def reservations
    context.scoped_set!(:current_tenant, object)

    # retrieve reservations
  end
end

The problem arises when returning reservations for multiple tenants are being returned at once. In the subtree for tenant A, we return a reservation owned by tenant B, which should be returned as a AnonymousReservation. In the subtree for tenant B that same reservation should be returned as a Reservation, because it's owned by tenant B.

However, graphql-ruby caches type resolutions for each object. So if a reservation was once resolved as Reservation, it cannot be resolved as another type in the same query anymore. We return same reservations as different Ruby objects, but Active Record implements hash, so those will get treated as being the same in graphql-ruby's hash, because they have the same record ID.

Type resolution is super cheap in our case, so we don't need the cache. Is there a way to skip it?

[rmosolgo]

Hey, thanks for sharing this use case. I can see how, at a minimum, context is an input to the cache here (that is, the cache would be scoped to certain context values). But that's not practical to implement, so as you point out, it'd be better to provide an escape hatch to cover scenarios like this.