Cómo utilizar HotChocolate para aplicar la directiva clave a tipos de objetos en GraphQL

Optimización de tipos de objetos con directiva clave en HotChocolate

Al usar GraphQL con HotChocolate, es posible que necesite expandir sus tipos de objetos con directivas, como @llave directiva, para garantizar la compatibilidad con Apollo Federation. Esto es especialmente importante para los esquemas federados, en los que las claves identifican entidades en varios servicios. Es fundamental comprender cómo diseñar adecuadamente los tipos de objetos con estas directivas.

Este artículo le mostrará cómo utilizar chocolate caliente para decorar tipos de objetos usando el @llave directiva. También veremos ejemplos particulares que utilizan código C# para construir un sistema simple. Padre clase y cómo cambiar el esquema GraphQL producido. El énfasis estará en las acciones reales que puede realizar para crear esta funcionalidad.

Cuando se utiliza HotChocolate para construir tipos de objetos GraphQL, el @llave Es posible que la directiva no se aplique inmediatamente como se esperaba. En cambio, el esquema puede producir una estructura de tipo simple que carece de las características críticas necesarias para la federación. Repasaremos cómo resolver esto y hacer que su esquema funcione como se esperaba.

También cubriremos tareas de configuración cruciales, como modificar la configuración de su servidor GraphQL y usar el software correcto. chocolate caliente y Federación Apolo paquetes. Con la configuración adecuada, puede aplicar directivas fácilmente y garantizar una federación de esquemas adecuada para sus servicios.

Comprender el papel de las directivas clave en HotChocolate

El primer script explica cómo implementar el @llave directiva usando HotChocolate en C#. Este script garantiza que el esquema GraphQL creado contiene el @llave directiva para la federación con la Federación Apollo. El guión comienza creando un Padre clase y asignando el [Llave] y [IDENTIFICACIÓN] atributos a sus campos. Estas propiedades son importantes para informar a HotChocolate para marcar el identificación campo como identificador único de la entidad. Esto es crucial al crear un servicio GraphQL federado en el que las entidades se pueden compartir entre varios servicios. Marcar este campo permite que el servicio GraphQL resuelva la entidad en consultas federadas.

El Resolución de referencia La función también es un componente esencial del guión. Esta función estática permite a HotChocolate resolver la entidad buscando la Padre objeto en un repositorio. El Repositorio principal está registrado en el servidor GraphQL y el Conseguir El método recupera un padre por su identificación. En el código de arranque, el .AddQueryType La instrucción registra el Consulta objeto, que se utiliza para ejecutar consultas GraphQL. RegisterService permite inyectar dependencias como ParentRepository en solucionadores GraphQL. Este diseño simplifica la recuperación de datos al tiempo que preserva una clara separación de preocupaciones.

El segundo ejemplo adopta un enfoque de esquema primero, utilizando GraphQL SDL (lenguaje de definición de esquema) para definir el @llave directiva dentro del esquema. Esta solución es especialmente eficaz para equipos que ya están familiarizados con la sintaxis SDL de GraphQL. En este ejemplo, el @llave La directiva se aplica a la Padre tipo, indicando claramente el identificación campo como identificador único. El uso de esquema primero permite a los desarrolladores tener más control sobre cómo se construye el esquema GraphQL y modificarlo sin tener que acceder al código C#, lo que lo convierte en una opción más flexible para equipos más grandes.

Finalmente, el componente de prueba unitaria valida que el código funcione según lo previsto. Usando el marco de prueba xUnit, Assert.The Contiene El comando garantiza que el esquema resultante incluya el @llave directiva. Esta prueba valida el esquema para la presencia del @llave directiva, que confirma que el servicio está configurado correctamente para la federación. Las pruebas unitarias son una práctica recomendada para garantizar que los cambios en su esquema GraphQL o métodos de resolución no interrumpan la funcionalidad, especialmente en un sistema federado donde varios servicios deben operar juntos sin problemas.

using HotChocolate;
using HotChocolate.Types;
using HotChocolate.Types.Relay;
using Microsoft.Extensions.DependencyInjection;
public class Parent
{
    public Parent(string id, string name)
    {
        Id = id;
        Name = name;
    }
    [Key]
    [ID]
    public string Id { get; }
    public string Name { get; }
    [ReferenceResolver]
    public static Parent? Get(ParentRepository repository, string id)
    {
        return repository.GetParent(id);
    }
}
public class Query
{
    public Parent GetParent(string id, [Service] ParentRepository repository)
    {
        return repository.GetParent(id);
    }
}
public void ConfigureServices(IServiceCollection services)
{
    services.AddGraphQLServer()
        .AddQueryType<Query>()
        .RegisterService<ParentRepository>()
        .AddApolloFederation();
}

type Parent @key(fields: "id") {
    id: ID!
    name: String!
}
extend type Query {
    parent(id: ID!): Parent
}
extend type Mutation {
    createParent(id: ID!, name: String!): Parent
}
directive @key(fields: String!) on OBJECT | INTERFACE

schema {
    query: Query
    mutation: Mutation
}

using Xunit;
using HotChocolate.Execution;
using Microsoft.Extensions.DependencyInjection;
public class ParentTests
{
    [Fact]
    public async Task ParentSchema_ContainsKeyDirective()
    {
        var serviceCollection = new ServiceCollection();
        serviceCollection.AddGraphQLServer()
            .AddQueryType<Query>()
            .AddApolloFederation();
        var serviceProvider = serviceCollection.BuildServiceProvider();
        var schema = await serviceProvider.GetRequiredService<ISchemaAsync>().ExecuteAsync();
        Assert.Contains("@key(fields: \"id\")", schema.ToString());
    }
}

Mejora de GraphQL con Apollo Federation y HotChocolate

El uso de GraphQL con HotChocolate en un entorno federado requiere una unión de esquemas bien estructurada. Apollo Federation permite a los desarrolladores particionar esquemas en varios servicios manteniendo una interfaz uniforme. Usando el @llave directiva con HotChocolate, puede especificar cómo se resuelven las entidades GraphQL en varios servicios. Esto hace que su API sea más modular y escalable, lo cual es especialmente beneficioso en sistemas grandes y distribuidos donde varios equipos controlan diferentes aspectos del esquema GraphQL.

En un esquema federado típico, entidades como Padre pueden existir en muchos servicios. La Federación Apolo utiliza el @llave directiva para identificar de forma única una entidad basada en un campo específico, como identificación. El soporte de HotChocolate para Apollo Federation garantiza que su servicio se integre sin esfuerzo en una infraestructura más grande. Además de configurar claves, puede utilizar directivas de federación como como @extiende o @externo para gestionar campos de datos dispersos en varios microservicios, proporcionando una mayor flexibilidad para su configuración GraphQL.

Otro factor clave al utilizar HotChocolate es la optimización del rendimiento. La recuperación excesiva de datos es un problema común con las API GraphQL, particularmente en contextos federados. Utilizar los solucionadores correctos, como el Resolución de referencia descrito en casos anteriores, garantiza que su API entregue solo los datos requeridos sin búsquedas excesivas. Además, HotChocolate admite algoritmos avanzados de almacenamiento en caché y procesamiento por lotes de consultas, que pueden aumentar la velocidad de respuesta de la API y la eficiencia en un esquema federado.