model node-relation in graphql api in python

Question

in our neo4j database, "Device" node is connected to "DeviceFeature" node with one way relation called "has". I am trying to find an efficient way to model this in my graphql api. I am using Strawberry and FastAPI. The below code works but I guess there might be a better way to achieve this goal, possibly a better way than iteration over each device.

I would like to get devicefeature of a device by writring a graphql query like below:

query {
  get_device(limit:20) {
    TAC_CODE
    device
    type
    has {
      id
      TAC_CODE
      brand_name
      gsma_device_type
      manufacturer_name
      model_family
      operating_system
    }
  }
}

I would like to also be able to run the below query as well

query {
 get_device(limit:20) {
        TAC_CODE
        device
        type
}
}

My python code is:

@strawberry.type
class Device:
    TAC_CODE: Optional[int]
    device: Optional[str]
    type: Optional[str]
    has: Optional[List[DeviceFeature]] = None

@strawberry.type
class DeviceFeature:
    id: Optional[int]
    TAC_CODE:  Optional[str]
    brand_name: Optional[str]
    gsma_device_type: Optional[str]
    manufacturer_name: Optional[str]
    model_family: Optional[str]
    operating_system: Optional[str]

@strawberry.type
class DeviceFeatureQuery:
    @strawberry.field
    async def get_devicefeature(
         ... some code to run a cypher query


@strawberry.type
class DeviceQuery:
    @strawberry.field
    async def get_device(self, info:Info, filters: Optional[List[str]] = None, limit: Optional[int] = None) -> List['Device']:

        device_fields = info.return_type
        print("device_fields")
        print(device_fields)
        # Extract the names of the attributes of the 'Device' type
        device_attribute_names = {
  
                selection.name
                for field in info.selected_fields
                for selection in field.selections
                
            }
      
        cypher_query = "MATCH (c:Device)"
        where_conditions = []
        if filters:
            where_conditions = [f"{field} = '{value}'" for field, value in filters]
        if where_conditions:
            cypher_query += " WHERE " + " AND ".join(where_conditions)
        cypher_query += " RETURN c"
        if limit is not None:
            cypher_query += f" LIMIT {limit}"
        loop = asyncio.get_running_loop()
        neo4j_uri_instance=neo4j_uri(info.context['user']['access_token'])
        with neo4j_uri_instance.driver.session() as session:
            result = await loop.run_in_executor(None, session.run, cypher_query)
            devices = [Device(TAC_CODE=record['c']['TAC_CODE'],  device=record['c']['device'], type=record['c']['type']) for record in result]
            if "has" in device_attribute_names:
                print("request has 'has'")
                for device in devices:
            
                    device.has= await DeviceQuery.get_device_devicefeatures ( info,device.TAC_CODE)
                 
        return devices


    
    async def get_device_devicefeatures( info:Info,tac_code: int ) -> List[DeviceFeature]:
        access_token = info.context['user']['access_token']
        cypher_query = f"MATCH (d:Device)-[:HAS]->(df:DeviceFeature) where d.TAC_CODE={tac_code} RETURN df limit 10"
        #print (cypher_query)
        loop = asyncio.get_running_loop()
        neo4j_uri_instance=neo4j_uri(access_token)
        with neo4j_uri_instance.driver.session() as session:
            result = await loop.run_in_executor(None, session.run, cypher_query)
            device_features = [DeviceFeature(id=record['df']['id'],TAC_CODE=record['df']['TAC_CODE'],manufacturer_name =record['df']['manufacturer_name'], model_family=record['df']['model_family'], operating_system=record['df']['operating_system'], brand_name=record['df']['brand_name'], gsma_device_type=record['df']['gsma_device_type']) for record in result]
        return device_features