Field To Input

Rufe den Wert eines Feldes ab, manipuliere ihn und übergib ihn als Eingabe an ein anderes Feld oder eine Direktive – alles innerhalb derselben Operation.

Übergib den Wert des Feldes field als Eingabe an ein anderes Feld über $__field, und als Eingabe an eine Direktive über field @passOnwards(as: "variableName").

`$__field`

Übergib den Feldwert als Eingabe an ein anderes Feld. Die Syntax, um auf den Feldwert zu verweisen, lautet: $ (also das Symbol für eine Variable in GraphQL), gefolgt von __ und dem Alias oder dem Namen des Feldes.

Zum Beispiel wird der Wert des Feldes excerpt als $__excerpt referenziert, und postTitle: title wird als $__postTitle referenziert.

Die Antwort des zweiten Feldes kann selbst wieder als Eingabe für ein weiteres Feld verwendet werden:

{
  posts {
    excerpt
 
    # Referencing previous field with name "excerpt"
    isEmptyExcerpt: _isEmpty(value: $__excerpt)
 
    # Referencing previous field with alias "isEmptyExcerpt"
    isNotEmptyExcerpt: _not(value: $__isEmptyExcerpt)
  }
}

Die Antwort lautet:

{
  "data": {
    "posts": [
      {
        "excerpt": "Some post excerpt",
        "isEmptyExcerpt": false,
        "isNotEmptyExcerpt": true
      },
      {
        "excerpt": "",
        "isEmptyExcerpt": true,
        "isNotEmptyExcerpt": false
      }
    ]
  }
}

# This will fail because the reference to the field must appear after the field, not before
{
  posts {
    isEmptyExcerpt: _isEmpty(value: $__excerpt)
    excerpt
  }
}
 
# This will fail because the reference must be done within the same node
{
  posts {
    excerpt
  }
  isEmptyExcerpt: _isEmpty(value: $__excerpt)
}

Das Feld kann auch nicht aus einem Direktiv-Argument heraus referenziert werden (dafür verwende @passOnwards):

# This will fail because the reference can be only used as input to a field, not to a directive
{
  posts {
    hasComments
    title @include(if: $__hasComments)
  }
}

`@passOnwards`

Die Direktive @passOnwards macht den aufgelösten Wert eines Feldes über eine dynamische Variable für nachfolgende Direktiven verfügbar.

In der folgenden Query wird das Feld notHasComments zusammengesetzt, indem der Wert des Feldes hasComments abgerufen und sein Gegenteil berechnet wird. Das funktioniert so:

Der Wert des Feldes wird über @passOnwards verfügbar gemacht; er kann dann als Eingabe an jede nachfolgende Direktive übergeben werden
@applyField nimmt die Eingabe (exportiert unter der dynamischen Variable $postHasComments), wendet das globale Feld not darauf an und speichert das Ergebnis zurück im Feld

{
  posts {
    id
    hasComments
    notHasComments: hasComments
      @passOnwards(as: "postHasComments")
      @applyField(
        name: "_not"
        arguments: {
          value: $postHasComments
        },
        setResultInResponse: true
      )
  }
}

Das ergibt:

{
  "data": {
    "posts": [
      {
        "id": 1724,
        "hasComments": true,
        "notHasComments": false
      },
      {
        "id": 358,
        "hasComments": false,
        "notHasComments": true
      },
      {
        "id": 555,
        "hasComments": false,
        "notHasComments": true
      }
    ]
  }
}

Wir können auch den Wert eines beliebigen aufgelösten Feldes im Objekt abrufen, indem wir entweder den Alias oder den Feldnamen unter dem Argument property übergeben.

In dieser Query greifen wir zum Beispiel auf den aufgelösten Wert über den Feldnamen id oder den Alias second zu und exportieren diesen Wert über eine dynamische Variable, um ihn in einer nachfolgenden Query auszugeben:

query One {
  id
  second: _echo(value: 2)
    @passOnwards(
      property: "id",
      as: "resolvedFirstValue"
    )
    @exportFrom(
      scopedDynamicVariable: $resolvedFirstValue,
      as: "firstValue"
    )
  third: _echo(value: 3)
    @passOnwards(
      property: "second",
      as: "resolvedSecondValue"
    )
    @exportFrom(
      scopedDynamicVariable: $resolvedSecondValue,
      as: "secondValue"
    )
}
 
query Two @depends(on: "One") {
  firstValue: _echo(value: $firstValue)
  secondValue: _echo(value: $secondValue)
}

Das ergibt:

{
  "data": {
    "id": "root",
    "second": 2,
    "third": 3,
    "firstValue": "root",
    "secondValue": 2
  }
}

Beispiele

Falls der Auszug eines Beitrags leer ist, verwende stattdessen den Titel:

{
  posts {
    title
    originalExcerpt: excerpt
    isEmptyExcerpt: _isEmpty(value: $__originalExcerpt)
    excerpt: _if(condition: $__isEmptyExcerpt, then: $__title, else: $__originalExcerpt)
  }
}

Rufe Daten von einem externen REST-Endpunkt ab und verarbeite sie nach deinen Anforderungen.

{
  externalData: _sendJSONObjectItemHTTPRequest(input: { url: "https://example.com/rest/some-external-endpoint"} )
  userName: _objectProperty(object: $__externalData, by: { path: "data.user.name" })
  userLastName: _objectProperty(object: $__externalData, by: { path: "data.user.surname" })
}

Das ergibt:

{
  "data": {
    "externalData": {
      "data": {
        "user": {
          "id": 1,
          "name": "Leo",
          "surname": "Loso"
        }
      }
    },
    "userName": "Leo",
    "userLastName": "Loso"
  }
}

Durch die Verwendung der Direktive @remove auf externalData können wir auch vermeiden, dass die Quelldaten des externen Endpunkts in der Antwort ausgegeben werden:

{
  externalData: _sendJSONObjectItemHTTPRequest(input: { url: "https://example.com/rest/some-external-endpoint" } ) @remove
  userName: _objectProperty(object: $__externalData, by: { path: "data.user.name" })
  userLastName: _objectProperty(object: $__externalData, by: { path: "data.user.surname" })
}

Das ergibt jetzt:

{
  "data": {
    "userName": "Leo",
    "userLastName": "Loso"
  }
}

Rufe die Beiträge jedes Benutzers ab, die die E-Mail-Adresse des Benutzers erwähnen:

{
  users {
    email
    posts(filter: { search: $__email }) {
      id
      title
    }
  }
}

Sende einen Newsletter, wobei die to- und from-E-Mail-Adressen über das Feld optionValue definiert werden:

mutation {
  fromEmail: optionValue(name: "admin_email")
  toEmail: optionValue(name: "subscribers_email_list_recipient_address")
  _sendEmail(
    from: {
      email: $__fromEmail
    }
    to: $__toEmail
    subject: "Weekly summary"
    messageAs: {
      html: "..."
    }
  )
}

Führe bedingte Operationen basierend auf dem Wert des Feldes aus. In dieser Query werden die Namen der Benutzer "Leo" und "Peter" in Großbuchstaben umgewandelt, da sie im Array der „besonderen Benutzer" enthalten sind, während "Martin" nicht umgewandelt wird:

query {
  users {
    name
      @passOnwards(as: "userName")
      @applyField(
        name: "_inArray"
        arguments: {
          value: $userName
          array: ["Leo", "John", "Peter"]
        }
        passOnwardsAs: "isSpecialUser"
      )
      @if(
        condition: $isSpecialUser
      )
        @strUpperCase
  }
}

...was folgendes ergibt:

{
  "data": {
    "users": [
      {
        "name": "LEO"
      },
      {
        "name": "Martin"
      },
      {
        "name": "PETER"
      }
    ]
  }
}

​$__field

​@passOnwards

​Beispiele

`$__field`

`@passOnwards`

Beispiele