How fix error: “Expected value of type \”*GQL\“ but got: *.”?

[thorin072]

Hello!
At the data schema level in SQLAlchemy, all tables are linked through a relationship. I have the following GraphQL data schema:

class CategoryGQL(SQLAlchemyObjectType):
    class Meta:
        proxy = True
        description = "Table of category"
        model = CategoryModel
        interfaces = [relay.Node]

class DOOPGQL(SQLAlchemyObjectType):
    class Meta:
        proxy = True
        description = "Table of DOOP"
        model = DOOPModel
        interfaces = (relay.Node,)

class DirectionGQL(SQLAlchemyObjectType):
    class Meta:
        description = "Table of direction"
        model = DirectionModel
        interfaces = [relay.Node]

class Category_DOOPGQL(SQLAlchemyObjectType):
    class Meta:
        description = "Category and Doop relationship table"
        model = Category_DOOP_Model
        interfaces = (relay.Node,)

I also implement this resolver. I got the error: Received incompatible instance, if I didn't use lambda with the first parameter graphene.List():

class AdvancedSearch(ObjectType):
    age = List(graphene.NonNull(graphene.String))  # [Array!]
    direction = List(graphene.NonNull(graphene.String))  # [Array!]
    ovz = graphene.Boolean()

    doops = graphene.List(lambda: graphene.List(DOOPGQL),ovz=ovz,age=age,direction=direction)
    
    def resolve_doops(self,info):
        query = db.query(DOOP,Direction,Category,Category_DOOP)
        query = query.filter_by(ovz=self.ovz)
        query = query.join(Direction, Direction.id_cluster == DOOP.id_cluster)
        query = query.filter(Direction.name.in_(self.direction))
        query = query.join(Category_DOOP, Category_DOOP.id_doop == DOOP.id)
        query = query.join(Category, Category_DOOP.id_category == Category.id)
        query = query.filter(Category.age_max.in_(self.age),Category.age_min.in_(self.age))
        query = query.all()
        return query

I get this answer:

"errors": [
    {
      "message": "Expected value of type \"DOOPGQL\" but got: Direction.",
      "locations": [
        {
          "line": 3,
          "column": 5
        }
      ]
    },
    {
      "message": "Expected value of type \"DOOPGQL\" but got: Category.",
      "locations": [
        {
          "line": 3,
          "column": 5
        }
      ]
    },
    {
      "message": "Expected value of type \"DOOPGQL\" but got: Category_DOOP.",
      "locations": [
        {
          "line": 3,
          "column": 5
        }
      ]
    }
  ]

I tried different ways. I changed the names of the tables in lambda: graphene. List(DOOPGQL), but I had 1\4 tables working. Maybe I'm returning a request, but not in the format that GraphQL is waiting for?

[chrisberks]

class Query(graphene.ObjectType):
    advanced_search = graphene.Field(
        graphene.List(DOOPGQL),
        age=graphene.List(graphene.NonNull(graphene.String)),
        direction=graphene.List(graphene.NonNull(graphene.String)),
        ovz=graphene.Boolean(),
    )

    def resolve_advanced_search(self, info, age, direction, ovz=False):
        return (
            db.query(DOOP)
            # filters ...
            .all()
        )

[thorin072]

@chrisberks Chris, thank you! I realized my mistake, and complicated the resolver. Let me ask you one more question: can I change advanced_search so that I can run queries like this:

query{
  Getallresources(age:["10","14","17","15"],direction:["Blender"],ovz:true){
    doop{
      id
      ovz
      direction
    }
    events{
      id
      ovz
      udo
    }    
}

Or is it easier to write a separate resolver?

[chrisberks]

It's hard to say without understanding the structure of the data. How are events related to doop ... or is a resource either a doop or an event?

[thorin072]

@chrisberks I'll make some specifics: the DOOP table is linked to theEventtable via the Attachments table. In the Аttachment table, the keys id_doop and id_event exist, there are also connections via GraphQL.

[chrisberks]

If I'm understanding what you're trying to do, you can achive this with a Union. See Search all Models with Union in the docs.
Let me know if this isn't what you had in mind.

[thorin072]

@chrisberks Today I made an attempt to rewrite the filter. I found that for the request format I needed, I needed to use the interface. Following the instructions https://docs.graphene-python.org/en/latest/types/interfaces/ I implemented the following class:

class Advanced_Filter(graphene.Interface):
    doops = graphene.List(lambda: DOOPGQL)
    event = graphene.List(lambda: EventGQL)
    #project = graphene.List(lambda: ProjectGQL)
    @classmethod
    def resolve_type(cls, instance, info):
        for el in instance:
            if isinstance(el, DOOPModel):
                return DOOPGQL
            if isinstance(el, EventModel):
                return EventGQL

Right now, the resolver looks like this:

  _getAllResources = graphene.Field(lambda: graphene.List(Advanced_Filter),
        description='Implements an extended filter for DOOP, Event, Project',
        age=graphene.List(graphene.NonNull(graphene.String)),
        direction=graphene.List(graphene.NonNull(graphene.String)),
        ovz=graphene.Boolean(required=True),
        type_search=graphene.String())

    def resolve__getAllResources(self, info, age, direction, ovz):
        answer = []
        answer.append(db.query(DOOP)
            .filter_by(ovz=ovz)
            .join(Direction, Direction.id_cluster == DOOP.id_cluster)
            .filter(Direction.name.in_(direction))
            .join(Category_DOOP, Category_DOOP.id_doop == DOOP.id)
            .join(Category, Category_DOOP.id_category == Category.id)
            .filter(Category.age_max.in_(age), Category.age_min.in_(age))
            .all())
        answer.append(db.query(Event)
            .all())
        return answer

I also noticed a bug that the answer contains 2 objects at the time of the request: doop and event, but when I debug, there is only one doop object in the instance, and the event object simply disappears from the final answer selection. Unfortunately, after all my attempts, I got this answer:

query{
  Getallresources(age:["10","14"],direction:["Code"],ovz:false){
  doops{id}
  event{id}
  }
}

{
  "data": {
    "Getallresources": [
      null,
      null
    ]
  },
  "errors": [
    {
      "message": "Could not find possible implementing types for Advanced_Filter in schema. Check that schema.types is defined and is an array ofall possible types in the schema."
    },
    {
      "message": "Could not find possible implementing types for Advanced_Filter in schema. Check that schema.types is defined and is an array ofall possible types in the schema."
    }
  ]
}

I would appreciate any ideas and thoughts, maybe they will help you find the right way to solve the problem.

[chrisberks]

Is the getAllResources field supposed to return all the DOOPs that match the arguments, plus the Events that are related to each DOOP?

[thorin072]

@chrisberks The technical specification for this resolver was as follows:

query getAllResources(age: Array!, direction: Array!, ovz: Boolean) {
	doops: [id: String!, directions: Array!, ovz: Boolean!, age: Array!, udo: {id: String!, name: String!, district: {id: String!, name: String!}}, ],
	events: [id: String!, directions: Array!, ovz: Boolean!, ages: Array!, udo: String!, district, startDate: Date, endDate],
	projects: [id, directions: [],name, udo, ovz]
}

I have formed a request body for the Event table, and the resolver takes this form:

 def resolve__getAllResources(self, info, age, direction, ovz):
        answer = []
        answer.append(db.query(DOOP)
            .filter_by(ovz=ovz)
            .join(Direction, Direction.id_cluster == DOOP.id_cluster)
            .filter(Direction.name.in_(direction))
            .join(Category_DOOP, Category_DOOP.id_doop == DOOP.id)
            .join(Category, Category_DOOP.id_category == Category.id)
            .filter(Category.age_max.in_(age), Category.age_min.in_(age))
            .all())
        answer.append(db.query(Event)
            .join(UDO, UDO.id == Event.id_udo)
            .join(DOOP, UDO.id == DOOP.id_udo)
            .join(Direction, Direction.id_cluster == DOOP.id_cluster)
            .filter_by(ovz=ovz)
            .filter(Direction.name.in_(direction))
            .join(Category_DOOP, Category_DOOP.id_doop == DOOP.id)
            .join(Category, Category_DOOP.id_category == Category.id)
            .filter(Category.age_max.in_(age), Category.age_min.in_(age))
            .all())
        return answer

In fact we are based on three parameters and use them to filter the tables and return all the results that were found

[chrisberks]

I'm not sure the getAllResources field makes sense from a GraphQL perspective. This structure implies that there is some concrete type Resource that has a List of doops, a List of events and a List of projects associated with it.

From what I can see, we want to return a list of Resources that match our search/filter criteria. A Resource in this case is one of the following: DOOPGQL, EventGQL, ProjectGQL. You can represent this in GraphQL using a union type:

union Resource = DOOPGQL | EventGQL | ProjectGQL

Define a union type using Graphene:

class Resource(graphene.Union):
    class Meta:
        types = (DOOPGQL, EventGQL, ProjectGQL)

We can now add a field getAllResources that returns a list of Resources:

class Query(graphene.ObjectType):
    get_all_resources = graphene.List(
        Resource,
        age=graphene.List(graphene.NonNull(graphene.String)),
        direction=graphene.List(graphene.NonNull(graphene.String)),
        ovz=graphene.Boolean(),
    )

    def resolve_get_all_resources(self, info, age, direction, ovz=False):
        # Get queries
        doop_query = DOOPGQL.get_query(info)
        event_query = EventGQL.get_query(info)
        project_query = ProjectGQL.get_query(info)

        # Query DOOPs, Events and Projects separately.
        doops = doop_query.filter( ... ).all()
        events = event_query.filter( ... ).all()
        projects = project_query.filter( ... ).all()

        # Combine results
        return doops + events + projects

Then use inline fragments to differentiate between the members, concrete types, of the Resource union type.

getAllResources( ... ) {
  ... on DOOPGQL {
    # select DOOPGQL fields
  }
  ... on EventGQL {
    # select EventGQL fields
  }
  ... on ProjectGQL {
    # select ProjectGQL fields
  }
}

The technical specification you referenced looks like a spec for a JSON endpoint. The word get in the field name is perhaps a clue to the fact that this is being looked at from a REST API perspective.

You could also argue that it's better to create three separate fields, one for each type. This way you can query for, say, Events without the resolver querying the database for all three types.

[thorin072]

@chrisberks Chris, I would like to thank you very much for your help, I can say that you led me by the hand through the documentation. A very interesting thing: .get_query(info) I didn't know about it. Finally, I figured out the Union and how to work with them correctly. The resolver works exactly as intended. Thank you again and good luck!

[chrisberks]

Thank you for that @thorin072, happy to help!

[github-actions]

This issue has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related topics referencing this issue.