Nested defer and order of payloads

[BoD]

Hi!

Let's say for instance we have this schema:

type Query {
    computer: Computer!
}

type Computer {
    cpu: String!
    year: Int!
    screen: Screen!
}

type Screen {
    resolution: String!
    isColor: Boolean!
}

And this query:

    query Screen {
      computer {
        __typename
        cpu
        ... on Computer @defer {
          year
          screen {
            __typename
            resolution
            ... on Screen @defer {
              isColor
            }
          }
        }
      }
    }

It looks like the response could be:

Payload 1

{
  "data": {
    "computer": {
      "__typename": "Computer",
      "cpu": "386"
    }
  },
  "hasNext": true
}

Payload 2

{
  "data": {
    "isColor": true
  },
  "path": [
    "computer",
    "screen"
  ],
  "hasNext": true
}

Payload 3

{
  "data": {
    "year": 1993,
    "screen": {
      "__typename": "Screen",
      "resolution": "640x480"
    }
  },
  "path": [
    "computer"
  ],
  "hasNext": false
}

Here a value for computer.screen.isColor could be received before computer.screen which could make code generation based implementations difficult.

My question is: should this really be allowed, or should the spec indicate that payloads should be emitted in a "hierarchical" order for nested cases like this one?

More context

Given this schema and query, here's what our (currently non defer-aware) tool generate:

class Data {
    computer: Computer
}

class Computer {
    __typename: String
    cpu: String
    onComputer: OnComputer
}

class OnComputer {
    year: Int
    screen: Screen
}

class Screen {
    __typename: String
    resolution: String
    onScreen: OnScreen
}

class OnScreen {
    isColor: Boolean
}

One simple evolution to make this defer-aware would be to make fragments possibly absent:

class Data {
    computer: Computer
}

class Computer {
    __typename: String
    cpu: String
    onComputer: Optional<OnComputer>
}

class OnComputer {
    year: Int
    screen: Screen
}

class Screen {
    __typename: String
    resolution: String
    onScreen: Optional<OnScreen>
}

class OnScreen {
    isColor: Boolean
}

But this approach doesn't really work if we can receive fields of data.onComputer.screen before the fields of date.onComputer.

[robrichard]

@BoD we have a discussion topic for this: #17

The latest code on the defer-stream branch will ensure the payloads are sent in the order you are expecting. This hasn't been published to npm yet.

[BoD]

Thank you, that is great news! 👍 (And sorry I didn't see it was already addressed).

I actually have a follow-up question but I'll add it there - I'll close this one.