Field To Input

Recupera el valor de un campo, manipúlalo y pásalo como entrada a otro campo o directiva, todo dentro de la misma operación.

Pasa el valor del campo field como entrada a otro campo mediante $__field, y como entrada a una directiva mediante field @passOnwards(as: "variableName").

`$__field`

Pasa el valor del campo como entrada a otro campo. La sintaxis para referenciar el valor del campo es: $ (es decir, el símbolo para una variable en GraphQL), seguido de __ y el alias o nombre del campo.

Por ejemplo, el valor del campo excerpt se referencia como $__excerpt, y postTitle: title se referencia como $__postTitle.

La respuesta del segundo campo puede a su vez usarse como entrada a otro campo:

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

La respuesta será:

{
  "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)
}

El campo tampoco puede referenciarse desde un argumento de directiva (para eso, usa @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`

La directiva @passOnwards hace que el valor resuelto del campo esté disponible para directivas posteriores mediante una variable dinámica.

En la consulta de abajo, el campo notHasComments se compone obteniendo el valor del campo hasComments y calculando su valor opuesto. Esto funciona así:

Haciendo que el valor del campo esté disponible mediante @passOnwards; el valor del campo puede entonces pasarse como entrada a cualquier directiva posterior
@applyField toma la entrada (exportada bajo la variable dinámica $postHasComments), aplica el campo global not sobre ella, y almacena el resultado de vuelta en el campo

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

Esto producirá:

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

También podemos recuperar el valor de cualquier campo resuelto en el objeto, pasando bien el alias o el nombre del campo bajo el arg property.

Por ejemplo, en esta consulta, accedemos al valor resuelto por el nombre del campo id, o el alias second, y exportamos ese valor mediante una variable dinámica para imprimirlo en una consulta posterior:

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)
}

Esto producirá:

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

Ejemplos

Si el extracto de la entrada está vacío, usa el título en su lugar:

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

Recupera datos de un endpoint REST externo, y manipula sus datos para que se ajusten a tus necesidades.

{
  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" })
}

Esto producirá:

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

Usando la directiva @remove sobre externalData, también podemos evitar imprimir los datos de origen del endpoint externo en la respuesta:

{
  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" })
}

Ahora esto producirá:

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

Recupera las entradas para cada usuario que mencionen el email del usuario:

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

Envía una newsletter definiendo los emails to y from mediante el campo optionValue:

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: "..."
    }
  )
}

Ejecuta operaciones condicionales basadas en el valor del campo. En esta consulta, los usuarios "Leo" y "Peter" ven sus nombres convertidos a mayúsculas, ya que están en el array de "usuarios especiales", mientras que "Martin" no:

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

...produciendo:

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

​$__field

​@passOnwards

​Ejemplos

`$__field`

`@passOnwards`

Ejemplos