Como usar HotChocolate para aplicar a diretiva chave a tipos de objetos no GraphQL

Otimizando tipos de objetos com diretiva chave no HotChocolate

Ao usar GraphQL com HotChocolate, pode ser necessário expandir seus tipos de objetos com diretivas, como @chave diretiva, para garantir a compatibilidade com a Apollo Federation. Isto é especialmente importante para esquemas federados, nos quais as chaves identificam entidades em vários serviços. Compreender como projetar adequadamente seus tipos de objetos com essas diretivas é fundamental.

Este artigo mostrará como usar Chocolate Quente para decorar tipos de objetos usando o @chave diretiva. Também veremos exemplos específicos utilizando código C# para construir um simples Pai classe e como alterar o esquema GraphQL produzido. A ênfase estará nas ações reais que você pode realizar para criar essa funcionalidade.

Ao usar HotChocolate para construir tipos de objetos GraphQL, o @chave directiva poderá não ser aplicada imediatamente como esperado. Em vez disso, o esquema pode produzir uma estrutura de tipo simples que não possui recursos críticos necessários para a federação. Veremos como resolver isso e fazer com que seu esquema funcione conforme o esperado.

Também abordaremos tarefas de configuração cruciais, como modificar a configuração do servidor GraphQL e usar o software correto Chocolate Quente e Federação Apolo pacotes. Com a configuração adequada, você pode aplicar diretivas facilmente e garantir a federação de esquema adequada para seus serviços.

Compreendendo o papel das principais diretivas no HotChocolate

O primeiro script explica como implementar o @chave diretiva usando HotChocolate em C#. Este script garante que o esquema GraphQL criado contém o @chave diretiva para federação com a Federação Apollo. O script começa criando um Pai classe e atribuindo o [Chave] e [EU IA] atributos para seus campos. Estas propriedades são importantes para informar o HotChocolate para marcar o eu ia campo como o identificador exclusivo da entidade. Isto é crucial ao criar um serviço GraphQL federado no qual as entidades podem ser compartilhadas entre vários serviços. Marcar este campo permite que o serviço GraphQL resolva a entidade em consultas federadas.

O ReferenceResolver function também é um componente essencial do script. Esta função estática permite que o HotChocolate resolva a entidade buscando o Pai objeto em um repositório. O Repositório Pai está registrado no servidor GraphQL e o Pegar método recupera um pai por seu eu ia. No código de inicialização, o .AddQueryType instrução registra o Consulta objeto, que é usado para executar consultas GraphQL.RegisterService permite injetar dependências como ParentRepository em resolvedores GraphQL. Esse design simplifica a recuperação de dados, preservando ao mesmo tempo uma clara separação de interesses.

O segundo exemplo adota uma abordagem de esquema primeiro, utilizando GraphQL SDL (Schema Definition Language) para definir o @chave diretiva dentro do esquema. Esta solução é especialmente eficaz para equipes que já estão familiarizadas com a sintaxe SDL do GraphQL. Neste exemplo, o @chave directiva é aplicada ao Pai tipo, indicando claramente o eu ia campo como o identificador exclusivo. Usar o esquema primeiro permite que os desenvolvedores tenham mais controle sobre como o esquema GraphQL é construído e modifique-o sem precisar entrar no código C#, tornando-o uma opção mais flexível para equipes maiores.

Finalmente, o componente de teste de unidade valida se o código funciona conforme planejado. Usando a estrutura de teste xUnit, o Assert.The Contém O comando garante que o esquema resultante inclua o @chave directiva. Este teste valida o esquema quanto à presença do @chave diretiva, confirmando que o serviço está configurado corretamente para a federação. O teste de unidade é uma prática recomendada para garantir que as alterações no esquema GraphQL ou nos métodos de resolução não interrompam a funcionalidade, especialmente em um sistema federado onde vários serviços devem operar juntos perfeitamente.

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

Aprimorando GraphQL com Apollo Federation e HotChocolate

Usar GraphQL com HotChocolate em um ambiente federado requer montagem de esquema bem estruturado. A Apollo Federation permite que os desenvolvedores particionem esquemas em vários serviços, mantendo uma interface uniforme. Usando o @chave diretiva com HotChocolate, você pode especificar como as entidades GraphQL são resolvidas em vários serviços. Isso torna sua API mais modular e escalonável, o que é especialmente benéfico em sistemas grandes e distribuídos, onde várias equipes controlam diferentes aspectos do esquema GraphQL.

Em um esquema federado típico, entidades como Pai podem existir em muitos serviços. A Federação Apollo usa o @chave diretiva para identificar exclusivamente uma entidade com base em um campo especificado, como eu ia. O suporte da HotChocolate para a Apollo Federation garante que seu serviço se integre facilmente a uma infraestrutura maior. Além de definir chaves, você pode usar diretivas de federação como @estende ou @externo para gerenciar campos de dados dispersos em vários microsserviços, proporcionando maior flexibilidade para a configuração do GraphQL.

Outro fator importante ao utilizar o HotChocolate é a otimização do desempenho. A busca excessiva de dados é um problema comum com APIs GraphQL, especialmente em contextos federados. Usando os resolvedores corretos, como o ReferenceResolver descrito em instâncias anteriores, garante que sua API forneça apenas os dados necessários, sem pesquisas excessivas. Além disso, o HotChocolate oferece suporte a algoritmos avançados de lote de consultas e cache, que podem aumentar a velocidade de resposta da API e a eficiência em um esquema federado.