Response construction

[Geal]

Is your feature request related to a problem? Please describe.
The response generated from subgraph responses does not match the query.
Examples with the federation demo:

field order

query ExampleQuery { me  {
  identifiant: id
  reviews { body }
 id 
} }

returns:

"data": {
    "moi": {
        "identifiant": "1",
        "__typename": "User",
        "id": "1",
        "reviews": [{
            "body": "Love it!"
        }, {
            "body": "Too expensive."
        }]
    }
}
}

The id field should appear after the reviews field, but because a first query to the accounts subgraph must be performed to obtained the id key, before requesting the review, the id is added to the response before the reviews

unnecessary data

query ExampleQuery {
 me  {
   reviews { body }
} }

returns

{
    "data": {
        "me": {
            "__typename": "User",
            "id": "1",
            "reviews": [{
                "body": "Love it!"
            }, {
                "body": "Too expensive."
            }]
        }
    }
}

The id field should not be there, but since it was used for the join, it was added by the response from the accounts subgraph.

These inconsistencies in the responses will block the work on integration testing #47, because they will generate a lot of differences between the gateway and router responses.

Describe the solution you'd like
The response should be created using the query plan, with only the required fields, in order, then subgraph responses would only be merged where it is necessary.

Describe alternatives you've considered
This work could be done as part of the future Rust query planner, but it looks like it can be done independently, only using the common query plan format.

[martijnwalraven]

Note that the expected field ordering is not static however, but depends on the runtime types of objects and on the values of variables that are used in @skip or @include.

That means you need to follow the GraphQL execution algorithm at least in spirit, although there are simplifications you can make. This is the step that is most relevant to this issue: http://spec.graphql.org/draft/#sec-Field-Collection

The way execution is implemented in graphql-js (and most other GraphQL servers) is fairly inefficient, because it is all AST-based. At least some parts of operations can be analyzed statically, and you could even come up with a more efficient representation that is specifically targeted at response shape computation. I have some ideas, and this is also related to the testing work I'm doing, but there are benefits to supporting execution proper in Rust so that may not be worth adopting.

[Geal]

right, if it requires some runtime info too it can become very tricky. Also, apparently the query plan we currently get from the harmonizer does not give info on the expected fields.
Example: the query query ExampleQuery {\n me {\n identifiant:id \n reviews { body }\n }\n \n}
gives us this plan:

Sequence {                                                                                                       
    nodes: [                                                                                                           
        Fetch(                                                                                                         
            FetchNode {                                                                                                
                service_name: "accounts",                                                                              
                requires: None,                                                                                        
                variable_usages: [],                                                                                   
                operation: "{me{identifiant:id __typename id}}",                                                       
            },                                                                                                         
        ),                                                                                                             
        Flatten(                                                                                                       
            FlattenNode {                                  
                path: Path(                                                                                            
                    [                                                                                                  
                        Key(                                                                                           
                            "me",                          
                        ),                                                                                             
                    ],                                                                                                 
                ),
                node: Fetch(                                                                                           
                    FetchNode {                                                                                        
                        service_name: "reviews",                                                                       
                        requires: Some(                                                                                                 
                            [                                                                                                           
                                InlineFragment(                     
                                    InlineFragment {                                                                                    
                                        type_condition: Some(                                                                           
                                            "User",                                                                                     
                                        ),                                                                                              
                                        selections: [                                                                                   
                                            Field(                                                                                      
                                                Field {                                                                                 
                                                    alias: None,                                                                        
                                                    name: "__typename",                                                                 
                                                    selections: None,                                                                   
                                                },                                                                                      
                                            ),                                                                                          
                                            Field(                                                                                      
                                                Field {                                                                                 
                                                    alias: None,                                                                        
                                                    name: "id",                                                                         
                                                    selections: None,                                                                   
                                                },                  
                                            ),                      
                                        ],                          
                                    },                              
                                ),                                  
                            ],                                      
                        ),                                          
                        variable_usages: [],                        
                        operation: "query($representations:[_Any!]!){_entities(representations:$representations){...on User{reviews{body}}}}",
                    },                                              
                ),                                                  
            },                                                      
        ),                                                          
    ],                                                              
}

[cecton]

In the current state I don't think we can address this issue. A good way to solve it would be to improve the query planner to include the information that is missing. When we do re-write the query planner in Rust we will be able to create our own format and improve a few things here and there like this one.

[martijnwalraven]

right, if it requires some runtime info too it can become very tricky. Also, apparently the query plan we currently get from the harmonizer does not give info on the expected fields.

Yeah, the query plan does not include the input query because that seems redundant. We could return a parsed representation of the query from JS in addition to the query plan if we wanted to avoid parsing in Rust, but it seems with apollo-rs we'd already have a similar representation in Rust.