Incremental Delivery Suggestions by yaacovCR · Pull Request #154 · yaacovCR/graphql-js

yaacovCR · 2022-02-04T09:31:38Z

Some of these were discussed during the Feb 2022 WG, some are new, possibly to be discussed in March :)

Execution:
= resolver functions for list fields should return AsyncIterables of Iterables, rather than just AsyncIterables to allow chunking
= change AsyncGenerator returned by execute to return an iterable of all available payloads instead of just the next payload

@stream:
= change stream payload to return an array for data, new atIndex property to specify the initial index for the array
= stream payloads currently act as error boundaries (as opposed to borking the entire stream/future payloads)
= add maxChunkSize Int argument for streaming in chunks
= add 'maxInterval' Int argument to send chunks before maxChunkSize if maxInterval ms have elapsed
= add 'inParallel' Boolean argument to allow sending items whenever ready, uses 'atIndices' instead of 'atIndex' to specify the indices of what is being returned

Related:
graphql/defer-stream-wg#32
graphql/defer-stream-wg#23
graphql/defer-stream-wg#17

split executor from graphql-js

slightly more cross platform

will fix with deprecation of getOperationRootType

The codebase should refer to functions that execute the query, mutation, and/or subscription root fields as such, rather than as functions that execute the operations themselves. Executing a query or mutation returns a map of data and errors, while executing the root fields returns the data of the root fields.

The `subscribe` method calls `createSourceEventStream` and `execute`, each of which normalize the request properties separately. By normalizing requests within the `subscribe` function, we can pass the normalized arguments to the implementation for `createSourceEventStream` and `execute`, i.e. new functions `createSourceEventStreamImpl` and `executeQueryOrMutation`.

The function is used only by `buildExecutionContext` and can be called there rather than exported

...into the same file!

* Move non-class Executor functions to end of file * Move memoized collectSubFields adjacent to class functions * Add buildPerPayloadExecutionContext function * Add main exports to executor ...in preparation for wrapping as class * Refactor Executor as class

* Export internal Executor class for experimentation This class, similar to the Parser class, is exported only to assist people in implementing their own executors without duplicating too much code and should be used only as last resort for cases such as experimental syntax or if certain features could not be contributed upstream. It is still part of the internal API (so far), so any changes to it are never considered breaking changes. The `graphql-executor` package must therefore be pinned to a specific patch version, e.g. `0.0.4`. * Fix README

to speed up ci, benchmarks irrelevant to execution can be retired

to reference graphql-executor instead of graphql-js

extracted from #154 relies on bundlers that can be used for batched streaming as well

when using `@stream`, the `data` property will be an array only when batching. when/if graphql-js changes to always send data as an array for streamed results, graphql-executor will do so as well. until then, data will be an array only when necessary, i.e. when batch streaming

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

* fix batched parallel stream error with defer where the initial responseNode was not added to the list using identical helpers for all bundlers makes this code better tested all around * add changeset

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

the Publisher and Bundler abstractions are such core parts of the execution algorithm that they probably belong within the execution folder (following the pattern of the map/flatten asyncIterable helpers)

to distinguish a single null item versus a null item in a list of non-nullable items where the null bubbles up to the list itself

...rather than just AsyncIterables to facilitate chunking

…ayloads rather than just a single payload

yaacovCR · 2022-03-30T18:55:02Z

Defer with fragments

Operation:

query HeroNameQuery {
  hero {
    id
    ...TopFragment @defer(label: "DeferTop")
  }
}
fragment TopFragment on Hero {
  name
  ...NestedFragment @defer(label: "DeferNested")
}
fragment NestedFragment on Hero {
  friends {
    name
  }
}

Response:

[
  {
    data: {
    hero: {
      id: '1',
    },
  },
    hasNext: true,
  },
  {
    data: {
      friends: [{ name: 'Han' }, { name: 'Leia' }, { name: 'C-3PO' }],
    },
    path: ['hero'],
    label: 'DeferNested',
    hasNext: true,
  },
  {
    data: {
      name: 'Luke',
    },
    path: ['hero'],
    label: 'DeferTop',
    hasNext: false,
  },
]

yaacovCR · 2022-03-30T18:55:28Z

Defer with slow field in initial payload

Operation:

query HeroNameQuery {
  hero {
    id
    ...NameFragment @defer
  }
}
fragment NameFragment on Hero {
  slowField
  friends {
    ...NestedFragment @defer
  }
}
fragment NestedFragment on Friend {
  name
}

Response:

Results in two sets of payloads.

[
  {
    data: {
      hero: { id: '1' },
    },
    hasNext: true,
  },
],
[
  {
    data: {
      slowField: 'slow',
      friends: [{}, {}, {}],
    },
    path: ['hero'],
    hasNext: true,
  },
  {
    data: { name: 'Han' },
    path: ['hero', 'friends', 0],
    hasNext: true,
  },
  {
    data: { name: 'Leia' },
    path: ['hero', 'friends', 1],
    hasNext: true,
  },
  {
    data: { name: 'C-3PO' },
    path: ['hero', 'friends', 2],
    hasNext: false,
  },
]

yaacovCR · 2022-03-30T18:55:50Z

Stream

Operation:

{
  scalarList @stream
}

OR

{
  scalarList @stream(initialCount: 1)
}

Response:

[
  {
    data: {
    scalarList: ['apple'],
  },
    hasNext: true,
  },
  {
    data: ['banana'],
    path: ['scalarList'],
    atIndex: 1,
    hasNext: true,
  },
  {
    data: ['coconut'],
    path: ['scalarList'],
    atIndex: 2,
    hasNext: false,
  },
]

yaacovCR · 2022-03-30T18:56:38Z

Stream with chunks of greater than 1

Operation:

{
  scalarList @stream(maxChunkSize: 2)
}

Response:

The first stream chunk hits its max.

[
  {
    data: {
      scalarList: [],
    },
    hasNext: true,
    },
  {
    data: ['apple', 'banana'],
    path: ['scalarList'],
    atIndex: 0,
    hasNext: true,
  },
  {
    data: ['coconut'],
    path: ['scalarList'],
    atIndex: 2,
    hasNext: false,
  },
]

yaacovCR · 2022-03-30T18:56:49Z

Stream in correct order even when the first item is slow

Operation:

query { 
  asyncSlowList @stream(initialCount: 0) {
    name
    id
  }
}

Response:

Note that a slow item 1 will move all the items to the second set of payloads.

[
  {
    data: {
      asyncSlowList: [],
    },
    hasNext: true,
  },
],
[
  {
    data: [
      {
        name: 'Luke',
        id: '1',
      },
    ],
    path: ['asyncSlowList'],
    atIndex: 0,
    hasNext: true,
  },
  {
    data: [
      {
        name: 'Han',
        id: '2',
      },
    ],
    path: ['asyncSlowList'],
    atIndex: 1,
    hasNext: true,
  },
  {
    data: [
      {
        name: 'Leia',
        id: '3',
      },
    ],
    path: ['asyncSlowList'],
    atIndex: 2,
    hasNext: false,
  },
]

yaacovCR · 2022-03-30T18:56:59Z

Stream in parallel

Operation:

query { 
  asyncSlowList @stream(initialCount: 0, maxChunkSize: 1, inParallel: true) {
    name
    id
  }
}

Response:

When streaming in parallel, the first set of payloads includes everything except the slow item 1.

[
  {
    data: {
      asyncSlowList: [],
    },
    hasNext: true,
  },
  {
    data: [
      {
        name: 'Han',
        id: '2',
      },
      {
        name: 'Leia',
        id: '3',
      },
    ],
    path: ['asyncSlowList'],
    atIndices: [1, 2],
    hasNext: true,
  },
],
[
  {
    data: [
      {
        name: 'Luke',
        id: '1',
      },
    ],
    path: ['asyncSlowList'],
    atIndices: [0],
    hasNext: false,
  },
]

yaacovCR · 2022-03-30T18:57:50Z

Stream with asyncIterableList

Operation:

query { 
  asyncIterableList @stream {
    name
    id
  }
}

OR

query { 
  asyncIterableList @stream(maxChunkSize: 1) {
    name
    id
  }
}

OR

query { 
  asyncIterableList @stream(maxChunkSize: 2, maxInterval: 1) {
    name
    id
  }
}

Response:

With AsyncIterables, each item will have to be in its own set of payloads, unless chunked. (The default maxChunkSize is 1.) But, even if chunked, if the interval elapses, it is sent separately before the chunk maxes out. So, a maxChunkSize greater than 1 could still end up sending smaller payloads if the maxInterval is exceeded.

[
  {
    data: {
      asyncIterableList: [],
    },
    hasNext: true,
  },
  {
    data: [
      {
        name: 'Luke',
        id: '1',
      },
    ],
    path: ['asyncIterableList'],
    atIndex: 0,
    hasNext: true,
  },
],
[
  {
    data: [
      {
        name: 'Han',
        id: '2',
      },
    ],
    path: ['asyncIterableList'],
    atIndex: 1,
    hasNext: true,
  },
],
[
  {
    data: [
    {
        name: 'Leia',
        id: '3',
    },
    ],
    path: ['asyncIterableList'],
    atIndex: 2,
    hasNext: true,
  },
  {
    hasNext: false,
  },
]

yaacovCR · 2022-03-30T18:57:59Z

Stream with asyncIterableList with chunk size > 1

Operation:

query { 
  asyncIterableList @stream(maxChunkSize: 2) {
    name
    id
  }
}

Response:

[
  {
    data: {
      asyncIterableList: [],
    },
    hasNext: true,
  },
  {
    data: [
      {
        name: 'Luke',
        id: '1',
      },
      {
        name: 'Han',
        id: '2',
      },
    ],
    path: ['asyncIterableList'],
    atIndex: 0,
    hasNext: true,
  },
],
[
  {
    data: [
    {
        name: 'Leia',
        id: '3',
    },
    ],
    path: ['asyncIterableList'],
    atIndex: 2,
    hasNext: true,
  },
  {
    hasNext: false,
  },
]

yaacovCR · 2022-03-30T18:58:11Z

Stream where a non-nullable item returns null

Operation:

query { 
  asyncIterableNonNullError @stream(initialCount: 1) {
    name
  }
}

Response:

[
  {
    data: {
      asyncIterableNonNullError: [
        {
          name: 'Luke',
        },
      ],
    },
    hasNext: true,
  },
  {
    data: null,
    path: ['asyncIterableNonNullError'],
    atIndex: 1,
    errors: [
      {
        message:
        'Cannot return null for non-nullable field Query.asyncIterableNonNullError.',
        locations: [
          {
            line: 3,
            column: 9,
          },
        ],
        path: ['asyncIterableNonNullError', 1],
      },
    ],
    hasNext: true,
  },
],
[
  {
    data: [
      {
        name: 'Han',
      },
    ],
    path: ['asyncIterableNonNullError'],
    atIndex: 2,
    hasNext: true,
  },
  {
    hasNext: false,
  },
]

yaacovCR · 2022-03-30T19:02:26Z

Examples:

Defer with fragments
Defer with slow field in initial payload
Stream
Stream with chunks of greater than 1
Stream in correct order even when the first item is slow
Stream in parallel
Stream with asyncIterableList
Stream with asyncIterableList with chunk size > 1
Stream where a non-nullable item returns null

yaacovCR · 2024-10-01T19:53:13Z

Returning to simple fork.

yaacovCR added 30 commits October 13, 2021 00:10

initial commit

6103489

split executor from graphql-js

add TODO to deprecate getOperationRootType

579be14

remove use of checkgit script until can make multiplatform

8a49bb1

add gitattributes for line ending standardization

bb58ab5

change cspell args for windows compatibility

687eaf8

0.0.2

18240e7

Merge remote-tracking branch 'upstream/main'

c352976

bring back checkgit script

6a0a2d3

slightly more cross platform

upgrade to latest rc

781e8b1

fix lockfile

7ed0895

remove unused test funcs from upstream

0e8609d

remove untested branch

d6eab2e

will fix with deprecation of getOperationRootType

Merge remote-tracking branch 'upstream/main'

154787e

remove unused files

76b46ee

update package.json

540453a

provide better fix for broken OperationTypeNode

ab3a5aa

Move call site for assertValidExecutionArguments (#3)

02029d7

The function is used only by `buildExecutionContext` and can be called there rather than exported

Correct comment for buildExecutionContext return type. (#4)

b42d472

Move subscription implemention alongside execution (#5)

ada80ac

...into the same file!

Move executor implementation to separate file (#6)

836a52e

0.0.3

8bdcf7e

Add v15 to ci (#9)

b3b4a59

Remove unnecessary benchmarks (#11)

4525624

to speed up ci, benchmarks irrelevant to execution can be retired

Correct README (#12)

df8898a

to reference graphql-executor instead of graphql-js

Add changesets for release management (#13)

0eeb3ca

Try to fix changesets (#14)

92d1428

yaacovCR added a commit that referenced this pull request Mar 18, 2022

introduce experimental parallel streaming

ed5420a

extracted from #154 relies on bundlers that can be used for batched streaming as well

introduce experimental parallel streaming (#160)

6b06772

extracted from #154 relies on bundlers that can be used for batched streaming as well

yaacovCR mentioned this pull request Mar 18, 2022

introduce experimental batched streaming #162

Merged

yaacovCR and others added 12 commits March 18, 2022 16:12

introduce experimental batched streaming (#162)

99a85d4

Update thin-maps-boil.md (#164)

b05f163

Version Packages (#161)

f390fd0

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

fix batched parallel stream error with defer (#165)

83d9258

* fix batched parallel stream error with defer where the initial responseNode was not added to the list using identical helpers for all bundlers makes this code better tested all around * add changeset

Version Packages (#166)

0f67733

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

refactor: introduce createBundler helper (#167)

6dc55f5

refactor: move execution utils to execution folder (#168)

3f4d149

the Publisher and Bundler abstractions are such core parts of the execution algorithm that they probably belong within the execution folder (following the pattern of the map/flatten asyncIterable helpers)

trim unused class member (#169)

223e19d

streamed data should always be wrapped in an array

fd9763b

to distinguish a single null item versus a null item in a list of non-nullable items where the null bubbles up to the list itself

resolvers for list fields should return AsyncIterables of Iterables

fd7d938

...rather than just AsyncIterables to facilitate chunking

AsyncGenerator should return an iterable of all currently available p…

63873a9

…ayloads rather than just a single payload

yaacovCR force-pushed the defer-stream-wg-changes branch from 5b32993 to 63873a9 Compare March 21, 2022 20:18

yaacovCR force-pushed the main branch from 305a030 to b751310 Compare October 1, 2024 09:35

yaacovCR closed this Oct 1, 2024

yaacovCR deleted the defer-stream-wg-changes branch March 29, 2026 18:58

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Incremental Delivery Suggestions#154

Incremental Delivery Suggestions#154
yaacovCR wants to merge 204 commits intomainfrom
defer-stream-wg-changes

yaacovCR commented Feb 4, 2022 •

edited

Loading

Uh oh!

yaacovCR commented Mar 30, 2022

Uh oh!

yaacovCR commented Mar 30, 2022

Uh oh!

yaacovCR commented Mar 30, 2022 •

edited

Loading

Uh oh!

yaacovCR commented Mar 30, 2022

Uh oh!

yaacovCR commented Mar 30, 2022

Uh oh!

yaacovCR commented Mar 30, 2022

Uh oh!

yaacovCR commented Mar 30, 2022

Uh oh!

yaacovCR commented Mar 30, 2022

Uh oh!

yaacovCR commented Mar 30, 2022

Uh oh!

yaacovCR commented Mar 30, 2022 •

edited

Loading

Uh oh!

yaacovCR commented Oct 1, 2024

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Conversation

yaacovCR commented Feb 4, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

yaacovCR commented Mar 30, 2022

Defer with fragments

Operation:

Response:

Uh oh!

yaacovCR commented Mar 30, 2022

Defer with slow field in initial payload

Operation:

Response:

Uh oh!

yaacovCR commented Mar 30, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Stream

Operation:

Response:

Uh oh!

yaacovCR commented Mar 30, 2022

Stream with chunks of greater than 1

Operation:

Response:

Uh oh!

yaacovCR commented Mar 30, 2022

Stream in correct order even when the first item is slow

Operation:

Response:

Uh oh!

yaacovCR commented Mar 30, 2022

Stream in parallel

Operation:

Response:

Uh oh!

yaacovCR commented Mar 30, 2022

Stream with asyncIterableList

Operation:

Response:

Uh oh!

yaacovCR commented Mar 30, 2022

Stream with asyncIterableList with chunk size > 1

Operation:

Response:

Uh oh!

yaacovCR commented Mar 30, 2022

Stream where a non-nullable item returns null

Operation:

Response:

Uh oh!

yaacovCR commented Mar 30, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Examples:

Uh oh!

yaacovCR commented Oct 1, 2024

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

yaacovCR commented Feb 4, 2022 •

edited

Loading

yaacovCR commented Mar 30, 2022 •

edited

Loading

yaacovCR commented Mar 30, 2022 •

edited

Loading