title: How to use DRF serializers with Graphene
body: <p>I am following <a href="http://docs.graphene-python.org/projects/django/en/latest/tutorial-plain/" rel="noreferrer">this tutorial</a> for using <strong>Graphene</strong> with <strong>Django</strong>, and everything was going smooth, until I reached the <a href="https://docs.graphene-python.org/projects/django/en/latest/mutations/#django-rest-framework" rel="noreferrer">Integration with Django Rest Framework section</a>.</p>
  
  <p>This section says that you can reuse <strong>DRF</strong> serializers with <strong>Graphene</strong>, by creating serializers clones, but it doesn't say what to do with such clones in order to reuse <strong>DRF</strong> serializers with <strong>Graphene</strong>.</p>
  
  <p>These are my serializers and clones:</p>
  
  <pre><code>from rest_framework import serializers
  from graphene_django.rest_framework.mutation import SerializerMutation
  from GeneralApp.models import Airport
  from ReservationsManagerApp.serializers import ReservationSerializer
  from ReservationsManagerApp.models import ReservationComponent, ReservationHotel, ReservationRoundtrip, ReservationTransfer, ReservationTour, ReservationService, Hotel
  
  class ReservationMutation(SerializerMutation):
      class Meta:
          serializer_class = ReservationSerializer
  
  class ReservationComponentGraphSerializer(serializers.ModelSerializer):
      component = serializers.SerializerMethodField()
  
      class Meta:
          model = ReservationComponent
          fields = ('id', 'reservation', 'dertour_bk', 'day', 'content_type', 'object_id', 'comment', 'is_invoiced', 'component')
  
      def get_component(self, instance):
          components_models = {
              'reservationhotel': ReservationHotel,
              'reservationroundtrip': ReservationRoundtrip,
              'reservationtransfer': ReservationTransfer,
              'reservationtour': ReservationTour,
              'reservationservice': ReservationService,
          }
  
          component = components_models[instance.content_type.model].objects.get(id=instance.object_id)
  
          return self.get_component_string(instance.content_type.model, component)
  
      def get_component_string(self, component_model, component):
          components_get_string = {
              'reservationhotel': self.get_hotel_string,
              'reservationroundtrip': self.get_roundtrip_string,
              'reservationtransfer': self.get_transfer_string,
              'reservationtour': self.get_tour_string,
              'reservationservice': self.get_service_string,
          }
  
          return components_get_string[component_model](component):
  
      def get_hotel_string(self, component):
          return component.hotel.name
  
      def get_roundtrip_string(self, component):
          return component.roundtrip.name
  
      def get_transfer_string(self, component):
          origin_str = self.get_place_str('origin', component)
          destination_str = self.get_place_str('destination', component)
  
          return "{} =&gt; {}".format(origin_str, destination_str)
  
      def get_place_str(self, case, component):
          places_models = {
              'airport': Airport,
              'hotel': Hotel,
          }
  
          if case == 'origin':
              return places_models[component.origin_content_type.model].objects.get(id=component.origin_object_id).name
          else:
              return places_models[component.destination_content_type.model].objects.get(id=component.destination_object_id).name
  
      def get_tour_string(self, component):
          return component.tour.name
  
      def get_service_string(self, component):
          return component.service.name
  
  class ReservationComponentMutation(SerializerMutation):
      class Meta:
          serializer_class = ReservationComponentGraphSerializer
  </code></pre>
  
  <p>And this is my <code>schemas.py</code>:</p>
  
  <pre><code>import graphene
  from graphene_django.types import DjangoObjectType
  from ReservationsManagerApp.models import   Reservation, ReservationComponent
  from InvoicesManagerApp.models import Invoice, InvoiceEntry, InvoiceEntryComponent
  from PaymentsManagerApp.models import Payment, PaymentReservationComponent
  
  class ReservationType(DjangoObjectType):
      class Meta:
          model = Reservation
  
  class ReservationComponentType(DjangoObjectType):
      class Meta:
          model = ReservationComponent
  
  class InvoiceType(DjangoObjectType):
      class Meta:
          model = Invoice
  
  class InvoiceEntryType(DjangoObjectType):
      class Meta:
          model = InvoiceEntry
  
  class InvoiceEntryComponentType(DjangoObjectType):
      class Meta:
          model = InvoiceEntryComponent
  
  class PaymentType(DjangoObjectType):
      class Meta:
          model = Payment
  
  class PaymentReservationComponentType(DjangoObjectType):
      class Meta:
          model = PaymentReservationComponent
  
  class  Query(object):
      all_reservations = graphene.List(ReservationType)
      all_reservation_components = graphene.List(ReservationComponentType)
      all_invoices = graphene.List(InvoiceType)
      all_invoice_components = graphene.List(InvoiceEntryType)
      all_invoice_entries_components = graphene.List(InvoiceEntryComponentType)
      all_payment = graphene.List(PaymentType)
      all_payment_reservation_components = graphene.List(PaymentReservationComponentType)
  
      def resolve_all_reservations(self, info, **kwargs):
          return Reservation.objects.all()
  
      def resolve_all_reservation_components(self, info, **kwargs):
          return ReservationComponent.objects.select_related('reservation').all()
  
      def resolve_all_invoice_entries_components(self, info, **kwargs):
          return InvoiceEntryComponent.objects.select_related('reservation_component').all()
  
      def resolve_all_payment_reservation_components(self, info, **kwargs):
          return PaymentReservationComponent.objects.select_related('reservation_component').all()
  </code></pre>
  
  <p>I don't know if I am missing something obvious, but I can't understand how am I suppose to use those serializers mutations with graphene. I guess it must be by configuring the <code>Query</code> class in some way, but I can't find a reference in the documentation. </p>