remove labels

Author: yaacovCR

spec/Section 3 -- Type System.md

@@ -2126,10 +2126,7 @@ scalar UUID @specifiedBy(url: "https://tools.ietf.org/html/rfc4122")
 ### @defer
 
 ```graphql
-directive @defer(
-  label: String
-  if: Boolean! = true
-) on FRAGMENT_SPREAD | INLINE_FRAGMENT
+directive @defer(if: Boolean! = true) on FRAGMENT_SPREAD | INLINE_FRAGMENT
 ```
 
 The `@defer` directive may be provided for fragment spreads and inline fragments
@@ -2144,7 +2141,7 @@ delivered in a subsequent response. `@include` and `@skip` take precedence over
 query myQuery($shouldDefer: Boolean) {
   user {
     name
-    ...someFragment @defer(label: "someLabel", if: $shouldDefer)
+    ...someFragment @defer(if: $shouldDefer)
   }
 }
 fragment someFragment on User {
@@ -2161,20 +2158,11 @@ fragment someFragment on User {
   [related note](#note-088b7)). When `false`, fragment will not be deferred and
   data will be included in the initial response. Defaults to `true` when
   omitted.
-- `label: String` - May be used by GraphQL clients to identify the data from
-  responses and associate it with the corresponding defer directive. If
-  provided, the GraphQL service must add it to the corresponding payload.
-  `label` must be unique label across all `@defer` and `@stream` directives in a
-  document. `label` must not be provided as a variable.
 
 ### @stream
 
 ```graphql
-directive @stream(
-  label: String
-  if: Boolean! = true
-  initialCount: Int = 0
-) on FIELD
+directive @stream(if: Boolean! = true, initialCount: Int = 0) on FIELD
 ```
 
 The `@stream` directive may be provided for a field of `List` type so that the
@@ -2186,7 +2174,7 @@ responses. `@include` and `@skip` take precedence over `@stream`.
 query myQuery($shouldStream: Boolean) {
   user {
     friends(first: 10) {
-      nodes @stream(label: "friendsStream", initialCount: 5, if: $shouldStream)
+      nodes @stream(initialCount: 5, if: $shouldStream)
     }
   }
 }
@@ -2198,11 +2186,6 @@ query myQuery($shouldStream: Boolean) {
   [related note](#note-088b7)). When `false`, the field will not be streamed and
   all list items will be included in the initial response. Defaults to `true`
   when omitted.
-- `label: String` - May be used by GraphQL clients to identify the data from
-  responses and associate it with the corresponding stream directive. If
-  provided, the GraphQL service must add it to the corresponding payload.
-  `label` must be unique label across all `@defer` and `@stream` directives in a
-  document. `label` must not be provided as a variable.
 - `initialCount: Int` - The number of list items the service should return as
   part of the initial response. If omitted, defaults to `0`. A field error will
   be raised if the value of this argument is less than `0`.

spec/Section 5 -- Validation.md

@@ -1605,71 +1605,6 @@ subscription sub {
 }
 ```
 
-### Defer And Stream Directive Labels Are Unique
-
-** Formal Specification **
-
-- Let {labelValues} be an empty set.
-- For every {directive} in the document:
-  - Let {directiveName} be the name of {directive}.
-  - If {directiveName} is "defer" or "stream":
-    - For every {argument} in {directive}:
-      - Let {argumentName} be the name of {argument}.
-      - Let {argumentValue} be the value passed to {argument}.
-      - If {argumentName} is "label":
-        - {argumentValue} must not be a variable.
-        - {argumentValue} must not be present in {labelValues}.
-        - Append {argumentValue} to {labelValues}.
-
-**Explanatory Text**
-
-The `@defer` and `@stream` directives each accept an argument "label". This
-label may be used by GraphQL clients to uniquely identify response payloads. If
-a label is passed, it must not be a variable and it must be unique within all
-other `@defer` and `@stream` directives in the document.
-
-For example the following document is valid:
-
-```graphql example
-{
-  dog {
-    ...fragmentOne
-    ...fragmentTwo @defer(label: "dogDefer")
-  }
-  pets @stream(label: "petStream") {
-    name
-  }
-}
-
-fragment fragmentOne on Dog {
-  name
-}
-
-fragment fragmentTwo on Dog {
-  owner {
-    name
-  }
-}
-```
-
-For example, the following document will not pass validation because the same
-label is used in different `@defer` and `@stream` directives.:
-
-```raw graphql counter-example
-{
-  dog {
-    ...fragmentOne @defer(label: "MyLabel")
-  }
-  pets @stream(label: "MyLabel") {
-    name
-  }
-}
-
-fragment fragmentOne on Dog {
-  name
-}
-```
-
 ### Stream Directives Are Used On List Fields
 
 **Formal Specification**

spec/Section 6 -- Execution.md

@@ -430,8 +430,8 @@ objectValue, variableValues, path, subsequentPayloads, asyncRecord):
     - Let {responseValue} be {ExecuteField(objectType, objectValue, fieldType,
       fields, variableValues, path, subsequentPayloads, asyncRecord)}.
     - Set {responseValue} as the value for {responseKey} in {resultMap}.
-- For each {deferredGroupFieldSet} and {label} in {deferredGroupedFieldsList}
-  - Call {ExecuteDeferredFragment(label, objectType, objectValue,
+- For each {deferredGroupFieldSet} in {deferredGroupedFieldsList}
+  - Call {ExecuteDeferredFragment(objectType, objectValue,
     deferredGroupFieldSet, path, variableValues, asyncRecord,
     subsequentPayloads)}
 - Return {resultMap}.
@@ -695,13 +695,10 @@ deferredGroupedFieldsList):
       with the next {selection} in {selectionSet}.
     - Let {fragmentSelectionSet} be the top-level selection set of {fragment}.
     - If {deferDirective} is defined:
-      - Let {label} be the value or the variable to {deferDirective}'s {label}
-        argument.
       - Let {deferredGroupedFields} be the result of calling
         {CollectFields(objectType, fragmentSelectionSet, variableValues,
         visitedFragments, deferredGroupedFieldsList)}.
-      - Append a record containing {label} and {deferredGroupedFields} to
-        {deferredGroupedFieldsList}.
+      - Append {deferredGroupedFields} to {deferredGroupedFieldsList}.
       - Continue with the next {selection} in {selectionSet}.
     - Let {fragmentGroupedFieldSet} be the result of calling
       {CollectFields(objectType, fragmentSelectionSet, variableValues,
@@ -725,13 +722,10 @@ deferredGroupedFieldsList):
       - If this execution is for a subscription operation, raise a _field
         error_.
     - If {deferDirective} is defined:
-      - Let {label} be the value or the variable to {deferDirective}'s {label}
-        argument.
       - Let {deferredGroupedFields} be the result of calling
         {CollectFields(objectType, fragmentSelectionSet, variableValues,
         visitedFragments, deferredGroupedFieldsList)}.
-      - Append a record containing {label} and {deferredGroupedFields} to
-        {deferredGroupedFieldsList}.
+      - Append {deferredGroupedFields} to {deferredGroupedFieldsList}.
       - Continue with the next {selection} in {selectionSet}.
     - Let {fragmentGroupedFieldSet} be the result of calling
       {CollectFields(objectType, fragmentSelectionSet, variableValues,
@@ -764,7 +758,6 @@ DoesFragmentTypeApply(objectType, fragmentType):
 An Async Payload Record is either a Deferred Fragment Record or a Stream Record.
 All Async Payload Records are structures containing:
 
-- {label}: value derived from the corresponding `@defer` or `@stream` directive.
 - {path}: a list of field names and indices from root to the location of the
   corresponding `@defer` or `@stream` directive.
 - {iterator}: The underlying iterator if created from a `@stream` directive.
@@ -776,10 +769,10 @@ All Async Payload Records are structures containing:
 
 #### Execute Deferred Fragment
 
-ExecuteDeferredFragment(label, objectType, objectValue, groupedFieldSet, path,
+ExecuteDeferredFragment(objectType, objectValue, groupedFieldSet, path,
 variableValues, parentRecord, subsequentPayloads):
 
-- Let {deferRecord} be an async payload record created from {label} and {path}.
+- Let {deferRecord} be an async payload record created from {path}.
 - Initialize {errors} on {deferRecord} to an empty list.
 - Let {dataExecution} be the asynchronous future value of:
   - Let {payload} be an unordered map.
@@ -803,8 +796,6 @@ variableValues, parentRecord, subsequentPayloads):
     - Add an entry to {payload} named `data` with the value {null}.
   - Otherwise:
     - Add an entry to {payload} named `data` with the value {resultMap}.
-  - If {label} is defined:
-    - Add an entry to {payload} named `label` with the value {label}.
   - Add an entry to {payload} named `path` with the value {path}.
   - Return {payload}.
 - Set {dataExecution} on {deferredFragmentRecord}.
@@ -965,11 +956,11 @@ yielded items satisfies `initialCount` specified on the `@stream` directive.
 
 #### Execute Stream Field
 
-ExecuteStreamField(label, iterator, index, fields, innerType, path,
-parentRecord, variableValues, subsequentPayloads):
+ExecuteStreamField(iterator, index, fields, innerType, path, parentRecord,
+variableValues, subsequentPayloads):
 
-- Let {streamRecord} be an async payload record created from {label}, {path},
-  and {iterator}.
+- Let {streamRecord} be an async payload record created from {path}, and
+  {iterator}.
 - Initialize {errors} on {streamRecord} to an empty list.
 - Let {itemPath} be {path} with {index} appended.
 - Let {dataExecution} be the asynchronous future value of:
@@ -987,7 +978,7 @@ parentRecord, variableValues, subsequentPayloads):
       item, variableValues, itemPath, subsequentPayloads, parentRecord)}.
     - Append any encountered field errors to {errors}.
     - Increment {index}.
-    - Call {ExecuteStreamField(label, iterator, index, fields, innerType, path,
+    - Call {ExecuteStreamField(iterator, index, fields, innerType, path,
       streamRecord, variableValues, subsequentPayloads)}.
     - If a field error was raised, causing a {null} to be propagated to {data},
       and {innerType} is a Non-Nullable type:
@@ -997,8 +988,6 @@ parentRecord, variableValues, subsequentPayloads):
         {data}.
   - If {errors} is not empty:
     - Add an entry to {payload} named `errors` with the value {errors}.
-  - If {label} is defined:
-    - Add an entry to {payload} named `label` with the value {label}.
   - Add an entry to {payload} named `path` with the value {itemPath}.
   - If {parentRecord} is defined:
     - Wait for the result of {dataExecution} on {parentRecord}.
@@ -1030,16 +1019,14 @@ subsequentPayloads, asyncRecord):
     - Let {initialCount} be the value or variable provided to
       {streamDirective}'s {initialCount} argument.
     - If {initialCount} is less than zero, raise a _field error_.
-    - Let {label} be the value or variable provided to {streamDirective}'s
-      {label} argument.
   - Let {iterator} be an iterator for {result}.
   - Let {items} be an empty list.
   - Let {index} be zero.
   - While {result} is not closed:
     - If {streamDirective} is defined and {index} is greater than or equal to
       {initialCount}:
-      - Call {ExecuteStreamField(label, iterator, index, fields, innerType,
-        path, asyncRecord, subsequentPayloads)}.
+      - Call {ExecuteStreamField(iterator, index, fields, innerType, path,
+        asyncRecord, subsequentPayloads)}.
       - Return {items}.
     - Otherwise:
       - Wait for the next item from {result} via the {iterator}.
@@ -1179,10 +1166,10 @@ error:
 ```graphql example
 {
   birthday {
-    ... @defer(label: "monthDefer") {
+    ... @defer {
       month
     }
-    ... @defer(label: "yearDefer") {
+    ... @defer {
       year
     }
   }
@@ -1198,32 +1185,29 @@ Response 1, the initial response is sent:
 }
 ```
 
-Response 2, the defer payload for label "monthDefer" is sent. The {data} entry
-has been set to {null}, as this {null} as propagated as high as the error
-boundary will allow.
+Response 2, a defer payload is sent. The {data} entry has been set to {null}, as
+this {null} as propagated as high as the error boundary will allow.
 
 ```json example
 {
   "incremental": [
     {
       "path": ["birthday"],
-      "label": "monthDefer",
       "data": null
     }
   ],
   "hasNext": false
 }
 ```
 
-Response 3, the defer payload for label "yearDefer" is sent. The data in this
-payload is unaffected by the previous null error.
+Response 3, another defer payload is sent. The data in this payload is
+unaffected by the previous null error.
 
 ```json example
 {
   "incremental": [
     {
       "path": ["birthday"],
-      "label": "yearDefer",
       "data": { "year": "2022" }
     }
   ],

spec/Section 7 -- Response.md

@@ -26,12 +26,10 @@ When the response of the GraphQL operation is a response stream, the first value
 will be the initial response. All subsequent values may contain an `incremental`
 entry, containing a list of Defer or Stream payloads.
 
-The `label` and `path` entries on Defer and Stream payloads are used by clients
-to identify the `@defer` or `@stream` directive from the GraphQL operation that
-triggered this response to be included in an `incremental` entry on a value
-returned by the response stream. When a label is provided, the combination of
-these two entries will be unique across all Defer and Stream payloads returned
-in the response stream.
+The `path` entries on Defer and Stream payloads are used by clients to identify
+the `@defer` or `@stream` directive from the GraphQL operation that triggered
+this response to be included in an `incremental` entry on a value returned by
+the response stream.
 
 If the response of the GraphQL operation is a response stream, each response map
 must contain an entry with key `hasNext`. The value of this entry is `true` for
@@ -275,9 +273,9 @@ For example, a query containing both defer and stream:
 ```graphql example
 query {
   person(id: "cGVvcGxlOjE=") {
-    ...HomeWorldFragment @defer(label: "homeWorldDefer")
+    ...HomeWorldFragment @defer
     name
-    films @stream(initialCount: 1, label: "filmsStream") {
+    films @stream(initialCount: 1) {
       title
     }
   }
@@ -312,12 +310,10 @@ Response 2, contains the defer payload and the first stream payload.
 {
   "incremental": [
     {
-      "label": "homeWorldDefer",
       "path": ["person"],
       "data": { "homeWorld": { "name": "Tatooine" } }
     },
     {
-      "label": "filmsStream",
       "path": ["person", "films", 1],
       "items": [{ "title": "The Empire Strikes Back" }]
     }
@@ -335,7 +331,6 @@ would be the final response.
 {
   "incremental": [
     {
-      "label": "filmsStream",
       "path": ["person", "films", 2],
       "items": [{ "title": "Return of the Jedi" }]
     }
@@ -359,7 +354,7 @@ iterator of the `films` field closes.
 A stream payload is a map that may appear as an item in the `incremental` entry
 of a response. A stream payload is the result of an associated `@stream`
 directive in the operation. A stream payload must contain `items` and `path`
-entries and may contain `label`, `errors`, and `extensions` entries.
+entries and may contain `errors` and `extensions` entries.
 
 ##### Items
 
@@ -374,7 +369,7 @@ than the list field with the associated `@stream` directive.
 A defer payload is a map that may appear as an item in the `incremental` entry
 of a response. A defer payload is the result of an associated `@defer` directive
 in the operation. A defer payload must contain `data` and `path` entries and may
-contain `label`, `errors`, and `extensions` entries.
+contain `errors` and `extensions` entries.
 
 ##### Data
 
@@ -411,14 +406,6 @@ of the field containing the associated `@defer` directive.
 When the `path` field is present on an "Error result", it indicates the response
 field which experienced the error.
 
-#### Label
-
-Stream and Defer payloads may contain a string field `label`. This `label` is
-the same label passed to the `@defer` or `@stream` directive associated with the
-response. This allows clients to identify which `@defer` or `@stream` directive
-is associated with this value. `label` will not be present if the corresponding
-`@defer` or `@stream` directive is not passed a `label` argument.
-
 ## Serialization Format
 
 GraphQL does not require a specific serialization format. However, clients