Internal GraphQL Server

Esta extensión instala un servidor GraphQL interno, que puede invocarse dentro de tu aplicación usando código PHP.

Entre otros casos de uso, puedes disparar la ejecución de una consulta GraphQL cuando ocurra alguna acción, para realizar alguna tarea relacionada (como enviar una notificación, añadir una entrada al log, validar una condición, etc).

​

Descripción

El servidor GraphQL interno se accede mediante la clase GatoGraphQL\InternalGraphQLServer\GraphQLServer, a través de estos tres métodos:

• executeQuery: Ejecuta una consulta GraphQL
• executeQueryInFile: Ejecuta una consulta GraphQL contenida en un archivo (.gql)
• executePersistedQuery: Ejecuta una persisted query de GraphQL (proporcionando su ID como int, o slug como string) (se requiere la extensión Persisted Queries)

Estas son las firmas de los métodos:

namespace GatoGraphQL\InternalGraphQLServer;
 
use PoP\Root\HttpFoundation\Response;
 
class GraphQLServer {
  /**
   * Execute a GraphQL query
   */
  public static function executeQuery(
    string $query,
    array $variables = [],
    ?string $operationName = null,
    int|string|null $schemaConfigurationIDOrSlug = null,
  ): Response {
    // ...
  }
 
 
  /**
   * Execute a GraphQL query contained in a (`.gql`) file
   */
  public static function executeQueryInFile(
    string $file,
    array $variables = [],
    ?string $operationName = null,
    int|string|null $schemaConfigurationIDOrSlug = null,
  ): Response {
    // ...
  }
 
 
  /**
   * Execute a persisted GraphQL query (providing its object
   * of type WP_Post, ID as an int, or slug as a string)
   */
  public static function executePersistedQuery(
    WP_Post|string|int $persistedQuery,
    array $variables = [],
    ?string $operationName = null
  ): Response {
    // ...
  }
}Copy

Para ejecutar una consulta GraphQL y obtener el contenido de la respuesta:

// Provide the GraphQL query
$query = "{ ... }";
 
// Execute the query against the internal server
$response = GraphQLServer::executeQuery($query);
 
// Get the content and decode it
$responseContent = json_decode($response->getContent(), true);
 
// Access the data and errors from the response
$responseData = $responseContent["data"] ?? [];
$responseErrors = $responseContent["errors"] ?? [];Copy

El objeto Response también contiene cualquier header producido (por ejemplo: si se aplicó alguna Cache Control List, añadiría el header Cache-Control):

$responseHeaders = $response->getHeaders();
$responseCacheControlHeader = $response->getHeaderLine('Cache-Control');Copy

Ten en cuenta que la clase GraphQLServer no está lista antes del hook init del core de WordPress.

​

Configuración del Esquema

El Internal GraphQL Server aplica su propia Configuración del Esquema. Por ejemplo, la predeterminada se selecciona en la página de Ajustes, bajo la pestaña "Internal GraphQL Server".

Esta configuración también se aplica cada vez que la consulta ejecutada contra el internal GraphQL server fue disparada por alguna otra consulta GraphQL mientras se resolvía en un endpoint con una configuración diferente (como el endpoint público graphql/).

Para ilustrar, supongamos que hemos configurado el endpoint único graphql/ para aplicar una Lista de Control de Acceso para validar usuarios por IP, y ejecutamos la mutación createPost contra este endpoint:

mutation {
  createPost(input: {...}) {
    # ...
  }
}Copy

De este modo, solo los visitantes desde esa IP podrán ejecutar esta mutación.

Luego hay un hook en publish_post que ejecuta alguna consulta contra el internal GraphQL server (por ejemplo: para enviar una notificación al administrador del sitio):

add_action(
  "publish_post",
  fn (int $post_id) => GraphQLServer::executeQuery("...", ["postID" => $post_id])
);Copy

Esta consulta GraphQL se resolverá usando la configuración del esquema aplicada al internal GraphQL server, y no al endpoint único graphql/.

Como resultado, la validación por IP de usuario no tendrá lugar (a menos que esa Lista de Control de Acceso también se haya aplicado al internal GraphQL server).

​

Depurando problemas

Para rastrear la ejecución de la consulta, podemos navegar por los logs.

Consulta Solución de problemas para más detalles.

​

Ejemplo

En este flujo de ejemplo (que también usa los módulos Multiple Query Execution, Helper Function Collection y Field to Input), cuando se crea una nueva entrada en el sitio, enviamos una notificación al usuario administrador.

Nos enganchamos a la acción del core de WordPress new_to_publish, recuperamos los datos de la entrada recién creada, y llamamos a GraphQLServer::executeQuery:

add_action(
  'new_to_publish',
  function (WP_Post $post) {
    if ($post->post_type !== 'post') {
      return;
    }
    // Check the contents of the query below
    $query = ' ... ';
    $variables = [
      'postTitle' => $post->post_title,
      'postContent' => $post->post_content,
    ]
    GraphQLServer::executeQuery($query, $variables, 'SendEmail');
  }
);Copy

...con esta consulta GraphQL:

query GetEmailData(
  $postTitle: String!,
  $postContent: String!
) {
  emailMessageTemplate: _strConvertMarkdownToHTML(
    text: """
 
There is a new post on the site: 
 
**{$postTitle}**:
 
{$postContent}
 
    """
  )
  emailMessage: _strReplaceMultiple(
    search: ["{$postTitle}", "{$postContent}"],
    replaceWith: [$postTitle, $postContent],
    in: $__emailMessageTemplate
  )
    @export(as: "emailMessage")
}
 
mutation SendEmail @depends(on: "GetEmailData") {
  _sendEmail(
    input: {
      to: "admin@site.com"
      subject: "There is a new post"
      messageAs: {
        html: $emailMessage
      }
    }
  ) {
    status
  }
}Copy