Logo
Query Functions
Query FunctionsDisparador de Errores en la Respuesta

Disparador de Errores en la Respuesta

Included in the “Power Extensions” bundle

Añade explícitamente una entrada de error a la respuesta para provocar el fallo de la petición GraphQL (cuando un campo no cumple con las condiciones esperadas).

Descripción

Este módulo añade campos y directivas para disparar errores explícitamente, y añadir advertencias, que se incluirán en la respuesta GraphQL.

Errores

El campo global _fail y la directiva @fail, que añaden una entrada a la propiedad errors en la respuesta, se añaden al esquema GraphQL.

query {
  _fail(message: "Some error")
  
  posts {
    featuredImage @fail(
      # condition: IS_NULL, \<= This is the default value
      message: "The post does not have a featured image"
    ) {
      id
      src
    }
  }
  
  users {
    name @fail(
      condition: IS_EMPTY,
      message: "The retrieved user does not have a name"
    )
  }
}

Ambos también pueden recibir el argumento data, para proporcionar información contextual en la respuesta de error.

Estos elementos del esquema son útiles para indicar explícitamente que hay un error en la consulta GraphQL ejecutada, siempre que dicho error no ocurra en circunstancias naturales.

Entonces, en nuestra aplicación del lado del cliente (como JavaScript con una configuración headless), podemos comprobar si la entrada errors existe y, basándonos en eso, procesar la respuesta GraphQL o mostrar un mensaje de error al usuario:

/**
 * If the response contains error(s), return a concatenated error message
 *
 * @param {Object} response A response object from the GraphQL server
 * @return {string|null} The error message or nothing
 */
const maybeGetErrorMessage = (response) => {
  if (response.errors && response.errors.length) {
    return sprintf(
      __(`The API produced the following error(s): "%s"`, 'gato-graphql'),
      response.errors.map(error => error.message).join( __('", "') )
    );
  }
  return null;
}
 
const maybeErrorMessage = maybeGetErrorMessage(response);
if (maybeErrorMessage) {
  // Show error to the user
  // ...
} else {
  // Process response
  // ...
}

Advertencias

El campo global _warn y la directiva @warn, que añaden una entrada a la propiedad warnings en la respuesta, se añaden al esquema GraphQL:

query {
  _warn(message: "Some warning")
  
  posts {
    id
    featuredImage {
      id
      src
    }
    doesNotHaveFeaturedImage: _isNull(value: $__featuredImage)
      @passOnwards(as: "doesNotHaveFeaturedImage")
      @if(condition: $doesNotHaveFeaturedImage)
        @warn(message: "The post does not have a featured image")
  }
}

Ambos también pueden recibir el argumento data, para proporcionar información contextual en la respuesta de advertencia.

Estos elementos del esquema son útiles para indicar que, aunque la consulta se ejecutó correctamente, alguna condición no era la esperada.

Ejemplos

Recuperar una entrada con un ID inexistente devolverá naturalmente null. Si necesitamos tratar esta condición como un error, podemos usar la directiva @fail:

query GetPost($id: ID!) {
  post(by:{id: $id})
    @fail(
      message: "There is no post with the provided ID"
      data: {
        id: $id
      }
    )
  {
    id
    title
  }
}

En combinación con la extensión Multiple Query Execution, podemos obtener los mismos resultados usando _fail (nótese que la operación FailIfPostNotExists no se ejecuta siempre que $postExists sea true):

query GetPost($id: ID!) {
  post(by:{id: $id}) {
    id
    title
  }
  _notNull(value: $__post) @export(as: "postExists")
}
 
query FailIfPostNotExists($id: ID!)
  @skip(if: $postExists)
  @depends(on: "GetPost")
{
  errorMessage: _sprintf(
    string: "There is no post with ID '%s'",
    values: [$id]
  ) @remove
  _fail(
    message: $__errorMessage
    data: {
      id: $id
    }
  ) @remove
}

Podemos usar _fail para asegurar que el usuario con el email dado aún no existe:

query EnsureUserDoesNotExist($userEmail: Email!) {
  user( by: { email: $userEmail } ) {
    _fail(
      message: "User with given email already exists"
      data: {
        email: $userEmail
      }
    )
  }
}
 
mutation CreateUser($userData: JSONObject!)
  @depends(on: "EnsureUserDoesNotExist")
{
  # ...
}

También podemos usar _fail para comprobar si recuperar datos de una API externa produjo errores:

query ConnectToExternalGraphQLAPI($endpoint: String!, $query: String!) {
  externalData: _sendGraphQLHTTPRequest(
    input: {
      endpoint: $endpoint
      query: $query
    }
  ) @export(as: "externalData")
  _propertyIsSetInJSONObject(
    object: $__externalData
    by: {
      key: "errors"
    }
  ) @export(as: "endpointHasErrors")
}
 
query FailIfExternalAPIHasErrors($endpoint: String!)
  @include(if: $endpointHasErrors)
  @depends(on: "ConnectToExternalGraphQLAPI")
{
  errorMessage: _sprintf(
    string: "Connecting to endpoint %s produced errors",
    values: [$endpoint]
  ) @remove
  data: _objectProperty(
    object: $externalData,
    by: {
      key: "errors"
    }
  ) @remove
  _fail(
    message: $__errorMessage
    data: {
      endpoint: $endpoint
      endpointData: $__data
    }
  ) @remove
}
 
query GetExternalAPIData
  @skip(if: $endpointHasErrors)
  @depends(on: "ConnectToExternalGraphQLAPI")
{
  data: _objectProperty(
    object: $externalData,
    by: {
      key: "data"
    }
  )
}