From f3a30f36867f51f7d99e782c99ff7ddf0cbfa397 Mon Sep 17 00:00:00 2001 From: Rob Richard Date: Tue, 7 Jan 2025 13:52:26 -0500 Subject: [PATCH 01/10] Spec edits for incremental delivery, Section 3 --- spec/Section 3 -- Type System.md | 113 ++++++++++++++++++++++++++++++- 1 file changed, 111 insertions(+), 2 deletions(-) diff --git a/spec/Section 3 -- Type System.md b/spec/Section 3 -- Type System.md index 7a6c5acec..c428d6ff5 100644 --- a/spec/Section 3 -- Type System.md +++ b/spec/Section 3 -- Type System.md @@ -816,8 +816,8 @@ And will yield the subset of each object type queried: When querying an Object, the resulting mapping of fields are conceptually ordered in the same order in which they were encountered during execution, excluding fragments for which the type does not apply and fields or fragments -that are skipped via `@skip` or `@include` directives. This ordering is -correctly produced when using the {CollectFields()} algorithm. +that are skipped via `@skip` or `@include` directives or postponed via `@defer`. +This ordering is correctly produced when using the {CollectFields()} algorithm. Response serialization formats capable of representing ordered maps should maintain this ordering. Serialization formats which can only represent unordered @@ -1973,6 +1973,14 @@ GraphQL implementations that support the type system definition language must provide the `@deprecated` directive if representing deprecated portions of the schema. +GraphQL implementations may provide the `@defer` and/or `@stream` directives. If +either or both of these directives are provided, they must conform to the +requirements defined in this specification. + +Note: The [Directives Are Defined](#sec-Directives-Are-Defined) validation rule +ensures that GraphQL Operations containing the `@defer` or `@stream` directives +cannot be executed by a GraphQL service that does not support them. + GraphQL implementations that support the type system definition language should provide the `@specifiedBy` directive if representing custom scalar definitions. @@ -2190,3 +2198,104 @@ to the relevant IETF specification. ```graphql example scalar UUID @specifiedBy(url: "https://tools.ietf.org/html/rfc4122") ``` + +### @defer + +```graphql +directive @defer( + label: String + if: Boolean! = true +) on FRAGMENT_SPREAD | INLINE_FRAGMENT +``` + +The `@defer` directive may be provided on a fragment spread or inline fragment +to indicate that execution of the related selection set should be deferred. When +a request includes the `@defer` directive, the result may consist of multiple +responses: the initial response containing all non-deferred data, while +subsequent responses include deferred data. + +The `@include` and `@skip` directives take precedence over `@defer`. + +```graphql example +query myQuery($shouldDefer: Boolean! = true) { + user { + name + ...someFragment @defer(label: "someLabel", if: $shouldDefer) + } +} +fragment someFragment on User { + id + profile_picture { + uri + } +} +``` + +#### @defer Arguments + +- `if: Boolean! = true` - When `true`, fragment _should_ be deferred (see + related note below). When `false`, fragment must not be deferred. Defaults to + `true` when omitted. +- `label: String` - An optional string literal (variables are disallowed) used + by GraphQL clients to identify data from responses and associate it with the + corresponding defer directive. If provided, the GraphQL service must include + this label in the corresponding pending object within the response. The + `label` argument must be unique across all `@defer` and `@stream` directives + in the document. + +### @stream + +```graphql +directive @stream( + label: String + if: Boolean! = true + initialCount: Int = 0 +) on FIELD +``` + +The `@stream` directive may be provided for a field whose type incorporates a +`List` type modifier; the directive enables the backend to leverage technology +such as asynchronous iterators to provide a partial list initially, and +additional list items in subsequent responses. + +The `@include` and `@skip` directives take precedence over `@stream`. + +```graphql example +query myQuery($shouldStream: Boolean! = true) { + user { + friends(first: 10) { + nodes + @stream(label: "friendsStream", initialCount: 5, if: $shouldStream) { + name + } + } + } +} +``` + +#### @stream Arguments + +- `if: Boolean! = true` - When `true`, field _should_ be streamed (see related + note below). When `false`, the field must not be streamed and all list items + must be initially included. Defaults to `true` when omitted. +- `label: String` - An optional string literal (variables are disallowed) used + by GraphQL clients to identify data from responses and associate it with the + corresponding stream directive. If provided, the GraphQL service must include + this label in the corresponding pending object within the result. The `label` + argument must be unique across all `@defer` and `@stream` directives in the + document. +- `initialCount: Int` - The number of list items the service should return + initially. If omitted, defaults to `0`. A field error will be raised if the + value of this argument is less than `0`. + +Note: The ability to defer and/or stream parts of a response can have a +potentially significant impact on application performance. Developers generally +need clear, predictable control over their application's performance. It is +highly recommended that GraphQL services honor the `@defer` and `@stream` +directives on each execution. However, the specification allows advanced use +cases where the service can determine that it is more performant to not defer +and/or stream. Therefore, GraphQL clients _must_ be able to process a response +that ignores the `@defer` and/or `@stream` directives. This also applies to the +`initialCount` argument on the `@stream` directive. Clients _must_ be able to +process a streamed response that contains a different number of initial list +items than what was specified in the `initialCount` argument. From e7cfcf06ffa945d89981d48ef307e893e4db9f32 Mon Sep 17 00:00:00 2001 From: Rob Richard Date: Fri, 10 Jan 2025 10:28:23 -0500 Subject: [PATCH 02/10] re-order arguments --- spec/Section 3 -- Type System.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/spec/Section 3 -- Type System.md b/spec/Section 3 -- Type System.md index c428d6ff5..40e14f126 100644 --- a/spec/Section 3 -- Type System.md +++ b/spec/Section 3 -- Type System.md @@ -2203,8 +2203,8 @@ scalar UUID @specifiedBy(url: "https://tools.ietf.org/html/rfc4122") ```graphql directive @defer( - label: String if: Boolean! = true + label: String ) on FRAGMENT_SPREAD | INLINE_FRAGMENT ``` @@ -2247,9 +2247,9 @@ fragment someFragment on User { ```graphql directive @stream( - label: String - if: Boolean! = true initialCount: Int = 0 + if: Boolean! = true + label: String ) on FIELD ``` @@ -2275,6 +2275,9 @@ query myQuery($shouldStream: Boolean! = true) { #### @stream Arguments +- `initialCount: Int` - The number of list items the service should return + initially. If omitted, defaults to `0`. A field error will be raised if the + value of this argument is less than `0`. - `if: Boolean! = true` - When `true`, field _should_ be streamed (see related note below). When `false`, the field must not be streamed and all list items must be initially included. Defaults to `true` when omitted. @@ -2284,9 +2287,6 @@ query myQuery($shouldStream: Boolean! = true) { this label in the corresponding pending object within the result. The `label` argument must be unique across all `@defer` and `@stream` directives in the document. -- `initialCount: Int` - The number of list items the service should return - initially. If omitted, defaults to `0`. A field error will be raised if the - value of this argument is less than `0`. Note: The ability to defer and/or stream parts of a response can have a potentially significant impact on application performance. Developers generally From df6125315fbc750c4cec69e8ffd76a6b9eef32b0 Mon Sep 17 00:00:00 2001 From: Rob Richard Date: Fri, 10 Jan 2025 12:03:59 -0500 Subject: [PATCH 03/10] Apply suggestions from code review Co-authored-by: Benjie --- spec/Section 3 -- Type System.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/spec/Section 3 -- Type System.md b/spec/Section 3 -- Type System.md index 40e14f126..dfd5971a9 100644 --- a/spec/Section 3 -- Type System.md +++ b/spec/Section 3 -- Type System.md @@ -2247,7 +2247,7 @@ fragment someFragment on User { ```graphql directive @stream( - initialCount: Int = 0 + initialCount: Int! = 0 if: Boolean! = true label: String ) on FIELD @@ -2275,7 +2275,7 @@ query myQuery($shouldStream: Boolean! = true) { #### @stream Arguments -- `initialCount: Int` - The number of list items the service should return +- `initialCount: Int! = 0` - The number of list items the service should return initially. If omitted, defaults to `0`. A field error will be raised if the value of this argument is less than `0`. - `if: Boolean! = true` - When `true`, field _should_ be streamed (see related From 96caa273a66e9a14828f187a53d9f77c59bd23e6 Mon Sep 17 00:00:00 2001 From: Rob Richard Date: Fri, 7 Feb 2025 16:19:46 -0500 Subject: [PATCH 04/10] Address PR feedback --- spec/Section 3 -- Type System.md | 56 +++++++++++++++++++------------- 1 file changed, 34 insertions(+), 22 deletions(-) diff --git a/spec/Section 3 -- Type System.md b/spec/Section 3 -- Type System.md index dfd5971a9..1171c1d7f 100644 --- a/spec/Section 3 -- Type System.md +++ b/spec/Section 3 -- Type System.md @@ -1978,8 +1978,9 @@ either or both of these directives are provided, they must conform to the requirements defined in this specification. Note: The [Directives Are Defined](#sec-Directives-Are-Defined) validation rule -ensures that GraphQL Operations containing the `@defer` or `@stream` directives -cannot be executed by a GraphQL service that does not support them. +ensures that GraphQL operations can only include directives available on the +schema; thus operations including `@defer` or `@stream` directives can only be +executed by a GraphQL service that supports them. GraphQL implementations that support the type system definition language should provide the `@specifiedBy` directive if representing custom scalar definitions. @@ -2254,20 +2255,21 @@ directive @stream( ``` The `@stream` directive may be provided for a field whose type incorporates a -`List` type modifier; the directive enables the backend to leverage technology -such as asynchronous iterators to provide a partial list initially, and -additional list items in subsequent responses. +`List` type modifier. The directive enables returning a partial list initially, +followed by additional items in subsequent responses. Should the field type +incorporate multiple `List` type modifiers, only the outermost list is streamed. + +Note: The mechanism through which items are streamed is implementation-defined +and may use technologies such as asynchronous iterators. The `@include` and `@skip` directives take precedence over `@stream`. ```graphql example query myQuery($shouldStream: Boolean! = true) { user { - friends(first: 10) { - nodes - @stream(label: "friendsStream", initialCount: 5, if: $shouldStream) { - name - } + friends(first: 10) + @stream(label: "friendsStream", initialCount: 5, if: $shouldStream) { + name } } } @@ -2275,18 +2277,28 @@ query myQuery($shouldStream: Boolean! = true) { #### @stream Arguments -- `initialCount: Int! = 0` - The number of list items the service should return - initially. If omitted, defaults to `0`. A field error will be raised if the - value of this argument is less than `0`. +- `initialCount: Int! = 0` - The number of list items to include initially. If + omitted, defaults to `0`. A field error will be raised if the value of this + argument is less than `0`. When the size of the list is greater than or equal + to the value of `initialCount`, the GraphQL service _must_ initially include + at least as many list items as the value of `initialCount` (see related note + below). - `if: Boolean! = true` - When `true`, field _should_ be streamed (see related - note below). When `false`, the field must not be streamed and all list items - must be initially included. Defaults to `true` when omitted. + note below). When `false`, the field must behave as if the `@stream` directive + is not present—it must not be streamed and all of the list items must be + included. Defaults to `true` when omitted. - `label: String` - An optional string literal (variables are disallowed) used by GraphQL clients to identify data from responses and associate it with the corresponding stream directive. If provided, the GraphQL service must include - this label in the corresponding pending object within the result. The `label` - argument must be unique across all `@defer` and `@stream` directives in the - document. + this label in the corresponding pending object within the response. The + `label` argument must be unique across all `@defer` and `@stream` directives + in the document. + +Note: The +[Defer And Stream Directive Labels Are Unique](#sec-Defer-And-Stream-Directive-Labels-Are-Unique) +validation rule ensures uniqueness of the values passed to `label` on both the +`@defer` and `@stream` directives. Variables are disallowed in the `label` +because their values may not be known during validation. Note: The ability to defer and/or stream parts of a response can have a potentially significant impact on application performance. Developers generally @@ -2295,7 +2307,7 @@ highly recommended that GraphQL services honor the `@defer` and `@stream` directives on each execution. However, the specification allows advanced use cases where the service can determine that it is more performant to not defer and/or stream. Therefore, GraphQL clients _must_ be able to process a response -that ignores the `@defer` and/or `@stream` directives. This also applies to the -`initialCount` argument on the `@stream` directive. Clients _must_ be able to -process a streamed response that contains a different number of initial list -items than what was specified in the `initialCount` argument. +that ignores individual `@defer` and/or `@stream` directives. This also applies +to the `initialCount` argument on the `@stream` directive. Clients must be able +to process a streamed response that contains more initial list items than what +was specified in the `initialCount` argument. From ebd706171db7819b0fa9f570576382d919930dce Mon Sep 17 00:00:00 2001 From: Rob Richard Date: Mon, 24 Feb 2025 14:25:21 -0500 Subject: [PATCH 05/10] Address PR feedback --- spec/Section 3 -- Type System.md | 58 ++++++++++++++++---------------- 1 file changed, 29 insertions(+), 29 deletions(-) diff --git a/spec/Section 3 -- Type System.md b/spec/Section 3 -- Type System.md index 1171c1d7f..7f0d24fb3 100644 --- a/spec/Section 3 -- Type System.md +++ b/spec/Section 3 -- Type System.md @@ -2211,9 +2211,9 @@ directive @defer( The `@defer` directive may be provided on a fragment spread or inline fragment to indicate that execution of the related selection set should be deferred. When -a request includes the `@defer` directive, the result may consist of multiple -responses: the initial response containing all non-deferred data, while -subsequent responses include deferred data. +a request includes the `@defer` directive, it may return an _incremental stream_ +consisting of an _initial response_ containing all non-deferred data, followed +by one or more _subsequent payloads_ including the deferred data. The `@include` and `@skip` directives take precedence over `@defer`. @@ -2238,11 +2238,11 @@ fragment someFragment on User { related note below). When `false`, fragment must not be deferred. Defaults to `true` when omitted. - `label: String` - An optional string literal (variables are disallowed) used - by GraphQL clients to identify data from responses and associate it with the - corresponding defer directive. If provided, the GraphQL service must include - this label in the corresponding pending object within the response. The - `label` argument must be unique across all `@defer` and `@stream` directives - in the document. + by GraphQL clients to identify data in the _incremental stream_ and associate + it with the corresponding defer directive. If provided, the GraphQL service + must include this label in the corresponding pending object within the + _incremental stream_. The `label` argument must be unique across all `@defer` + and `@stream` directives in the document. ### @stream @@ -2256,7 +2256,7 @@ directive @stream( The `@stream` directive may be provided for a field whose type incorporates a `List` type modifier. The directive enables returning a partial list initially, -followed by additional items in subsequent responses. Should the field type +followed by additional items in subsequent payloads. Should the field type incorporate multiple `List` type modifiers, only the outermost list is streamed. Note: The mechanism through which items are streamed is implementation-defined @@ -2277,22 +2277,22 @@ query myQuery($shouldStream: Boolean! = true) { #### @stream Arguments -- `initialCount: Int! = 0` - The number of list items to include initially. If - omitted, defaults to `0`. A field error will be raised if the value of this - argument is less than `0`. When the size of the list is greater than or equal - to the value of `initialCount`, the GraphQL service _must_ initially include - at least as many list items as the value of `initialCount` (see related note - below). +- `initialCount: Int! = 0` - The number of list items to include initially when + completing the parent selection set. If omitted, defaults to `0`. A field + error will be raised if the value of this argument is less than `0`. When the + size of the list is greater than or equal to the value of `initialCount`, the + GraphQL service _must_ initially include at least as many list items as the + value of `initialCount` (see related note below). - `if: Boolean! = true` - When `true`, field _should_ be streamed (see related note below). When `false`, the field must behave as if the `@stream` directive is not present—it must not be streamed and all of the list items must be included. Defaults to `true` when omitted. - `label: String` - An optional string literal (variables are disallowed) used - by GraphQL clients to identify data from responses and associate it with the - corresponding stream directive. If provided, the GraphQL service must include - this label in the corresponding pending object within the response. The - `label` argument must be unique across all `@defer` and `@stream` directives - in the document. + by GraphQL clients to identify data in the _incremental stream_ and associate + it with the corresponding stream directive. If provided, the GraphQL service + must include this label in the corresponding pending object within the + _incremental stream_. The `label` argument must be unique across all `@defer` + and `@stream` directives in the document. Note: The [Defer And Stream Directive Labels Are Unique](#sec-Defer-And-Stream-Directive-Labels-Are-Unique) @@ -2300,14 +2300,14 @@ validation rule ensures uniqueness of the values passed to `label` on both the `@defer` and `@stream` directives. Variables are disallowed in the `label` because their values may not be known during validation. -Note: The ability to defer and/or stream parts of a response can have a -potentially significant impact on application performance. Developers generally -need clear, predictable control over their application's performance. It is -highly recommended that GraphQL services honor the `@defer` and `@stream` -directives on each execution. However, the specification allows advanced use -cases where the service can determine that it is more performant to not defer -and/or stream. Therefore, GraphQL clients _must_ be able to process a response +Note: The ability to defer and/or stream data can have a potentially significant +impact on application performance. Developers generally need clear, predictable +control over their application's performance. It is highly recommended that +GraphQL services honor the `@defer` and `@stream` directives on each execution. +However, the specification allows advanced use cases where the service can +determine that it is more performant to not defer and/or stream. Therefore, +GraphQL clients _must_ be able to process a _response_ or _incremental stream_ that ignores individual `@defer` and/or `@stream` directives. This also applies to the `initialCount` argument on the `@stream` directive. Clients must be able -to process a streamed response that contains more initial list items than what -was specified in the `initialCount` argument. +to process a streamed field result that contains more initial list items than +what was specified in the `initialCount` argument. From f1abaac6f0200cd3ce0030f0e39e85aca302c011 Mon Sep 17 00:00:00 2001 From: Rob Richard Date: Thu, 6 Mar 2025 15:10:59 -0500 Subject: [PATCH 06/10] Update spec/Section 3 -- Type System.md Co-authored-by: Benoit 'BoD' Lubek --- spec/Section 3 -- Type System.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/spec/Section 3 -- Type System.md b/spec/Section 3 -- Type System.md index 7f0d24fb3..c0a5002ce 100644 --- a/spec/Section 3 -- Type System.md +++ b/spec/Section 3 -- Type System.md @@ -2256,8 +2256,9 @@ directive @stream( The `@stream` directive may be provided for a field whose type incorporates a `List` type modifier. The directive enables returning a partial list initially, -followed by additional items in subsequent payloads. Should the field type -incorporate multiple `List` type modifiers, only the outermost list is streamed. +followed by additional items in subsequent payloads. If the field type +incorporates multiple `List` type modifiers, only the outermost list is +streamed. Note: The mechanism through which items are streamed is implementation-defined and may use technologies such as asynchronous iterators. From 6df7b506709dee274ed5ca9a13fe14cc7a91a704 Mon Sep 17 00:00:00 2001 From: Rob Richard Date: Tue, 25 Mar 2025 07:47:15 -0400 Subject: [PATCH 07/10] Update response terminology --- spec/Section 3 -- Type System.md | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/spec/Section 3 -- Type System.md b/spec/Section 3 -- Type System.md index c0a5002ce..ee70101e4 100644 --- a/spec/Section 3 -- Type System.md +++ b/spec/Section 3 -- Type System.md @@ -2212,8 +2212,9 @@ directive @defer( The `@defer` directive may be provided on a fragment spread or inline fragment to indicate that execution of the related selection set should be deferred. When a request includes the `@defer` directive, it may return an _incremental stream_ -consisting of an _initial response_ containing all non-deferred data, followed -by one or more _subsequent payloads_ including the deferred data. +consisting of an _initial response payload_ containing all non-deferred data, +followed by one or more _subsequent response payload_ including the deferred +data. The `@include` and `@skip` directives take precedence over `@defer`. @@ -2307,8 +2308,8 @@ control over their application's performance. It is highly recommended that GraphQL services honor the `@defer` and `@stream` directives on each execution. However, the specification allows advanced use cases where the service can determine that it is more performant to not defer and/or stream. Therefore, -GraphQL clients _must_ be able to process a _response_ or _incremental stream_ -that ignores individual `@defer` and/or `@stream` directives. This also applies -to the `initialCount` argument on the `@stream` directive. Clients must be able -to process a streamed field result that contains more initial list items than -what was specified in the `initialCount` argument. +GraphQL clients _must_ be able to process a _response_ that ignores individual +`@defer` and/or `@stream` directives. This also applies to the `initialCount` +argument on the `@stream` directive. Clients must be able to process a streamed +field result that contains more initial list items than what was specified in +the `initialCount` argument. From 64dc38f42119b714a37ed51186e285c44ca0b4e8 Mon Sep 17 00:00:00 2001 From: Rob Richard Date: Tue, 1 Jul 2025 12:06:21 -0400 Subject: [PATCH 08/10] Use new execution result terminology --- spec/Section 3 -- Type System.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/spec/Section 3 -- Type System.md b/spec/Section 3 -- Type System.md index ee70101e4..c7473a211 100644 --- a/spec/Section 3 -- Type System.md +++ b/spec/Section 3 -- Type System.md @@ -2212,8 +2212,8 @@ directive @defer( The `@defer` directive may be provided on a fragment spread or inline fragment to indicate that execution of the related selection set should be deferred. When a request includes the `@defer` directive, it may return an _incremental stream_ -consisting of an _initial response payload_ containing all non-deferred data, -followed by one or more _subsequent response payload_ including the deferred +consisting of an _initial execution result_ containing all non-deferred data, +followed by one or more _subsequent execution result_ including the deferred data. The `@include` and `@skip` directives take precedence over `@defer`. @@ -2257,9 +2257,9 @@ directive @stream( The `@stream` directive may be provided for a field whose type incorporates a `List` type modifier. The directive enables returning a partial list initially, -followed by additional items in subsequent payloads. If the field type -incorporates multiple `List` type modifiers, only the outermost list is -streamed. +followed by additional items in one or more _subsequent execution result_. If +the field type incorporates multiple `List` type modifiers, only the outermost +list is streamed. Note: The mechanism through which items are streamed is implementation-defined and may use technologies such as asynchronous iterators. From 7de92f8f1668d30b25b445ede4317ee2d65f6582 Mon Sep 17 00:00:00 2001 From: Rob Richard Date: Mon, 21 Jul 2025 09:26:57 -0400 Subject: [PATCH 09/10] Update order of arguments on @stream --- spec/Section 3 -- Type System.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/spec/Section 3 -- Type System.md b/spec/Section 3 -- Type System.md index c7473a211..3bbbb84d1 100644 --- a/spec/Section 3 -- Type System.md +++ b/spec/Section 3 -- Type System.md @@ -2249,9 +2249,9 @@ fragment someFragment on User { ```graphql directive @stream( - initialCount: Int! = 0 if: Boolean! = true label: String + initialCount: Int! = 0 ) on FIELD ``` @@ -2279,12 +2279,6 @@ query myQuery($shouldStream: Boolean! = true) { #### @stream Arguments -- `initialCount: Int! = 0` - The number of list items to include initially when - completing the parent selection set. If omitted, defaults to `0`. A field - error will be raised if the value of this argument is less than `0`. When the - size of the list is greater than or equal to the value of `initialCount`, the - GraphQL service _must_ initially include at least as many list items as the - value of `initialCount` (see related note below). - `if: Boolean! = true` - When `true`, field _should_ be streamed (see related note below). When `false`, the field must behave as if the `@stream` directive is not present—it must not be streamed and all of the list items must be @@ -2295,6 +2289,12 @@ query myQuery($shouldStream: Boolean! = true) { must include this label in the corresponding pending object within the _incremental stream_. The `label` argument must be unique across all `@defer` and `@stream` directives in the document. +- `initialCount: Int! = 0` - The number of list items to include initially when + completing the parent selection set. If omitted, defaults to `0`. A field + error will be raised if the value of this argument is less than `0`. When the + size of the list is greater than or equal to the value of `initialCount`, the + GraphQL service _must_ initially include at least as many list items as the + value of `initialCount` (see related note below). Note: The [Defer And Stream Directive Labels Are Unique](#sec-Defer-And-Stream-Directive-Labels-Are-Unique) From 5d027622bf9ba70ec365d45ace1c4a538e5383c9 Mon Sep 17 00:00:00 2001 From: Rob Richard Date: Mon, 21 Jul 2025 09:28:45 -0400 Subject: [PATCH 10/10] field error -> execution error --- spec/Section 3 -- Type System.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/spec/Section 3 -- Type System.md b/spec/Section 3 -- Type System.md index 3bbbb84d1..c5d234515 100644 --- a/spec/Section 3 -- Type System.md +++ b/spec/Section 3 -- Type System.md @@ -2290,7 +2290,7 @@ query myQuery($shouldStream: Boolean! = true) { _incremental stream_. The `label` argument must be unique across all `@defer` and `@stream` directives in the document. - `initialCount: Int! = 0` - The number of list items to include initially when - completing the parent selection set. If omitted, defaults to `0`. A field + completing the parent selection set. If omitted, defaults to `0`. An execution error will be raised if the value of this argument is less than `0`. When the size of the list is greater than or equal to the value of `initialCount`, the GraphQL service _must_ initially include at least as many list items as the