Come utilizzare HotChocolate per applicare la direttiva chiave ai tipi di oggetto in GraphQL

Ottimizzazione dei tipi di oggetti con la direttiva chiave in HotChocolate

Quando utilizzi GraphQL con HotChocolate, potrebbe essere necessario espandere i tipi di oggetto con direttive, come ad esempio @chiave direttiva, per garantire la compatibilità con la Federazione Apollo. Ciò è particolarmente importante per gli schemi federati, in cui le chiavi identificano entità attraverso diversi servizi. Comprendere come progettare in modo appropriato i tipi di oggetto con queste direttive è fondamentale.

Questo articolo mostrerà come utilizzare Cioccolata calda per decorare tipi di oggetti utilizzando il file @chiave direttiva. Verranno inoltre esaminati esempi particolari che utilizzano codice C# per costruire un semplice Genitore classe e come modificare lo schema GraphQL prodotto. L'accento sarà posto sulle azioni effettive che potresti intraprendere per creare questa funzionalità.

Quando si utilizza HotChocolate per costruire tipi di oggetti GraphQL, il file @chiave La direttiva potrebbe non essere applicata immediatamente come previsto. Lo schema potrebbe invece produrre una struttura di tipo semplice priva delle funzionalità critiche richieste per la federazione. Esamineremo come risolvere questo problema e far sì che il tuo schema funzioni come previsto.

Tratteremo anche attività di configurazione cruciali, come la modifica della configurazione del server GraphQL e l'utilizzo del diritto Cioccolata calda E Federazione Apollo pacchetti. Con la configurazione corretta, puoi applicare facilmente le direttive e garantire la corretta federazione dello schema per i tuoi servizi.

Comprendere il ruolo delle direttive chiave in HotChocolate

Il primo script spiega come implementare il file @chiave direttiva che utilizza HotChocolate in C#. Questo script garantisce che lo schema GraphQL creato contenga il file @chiave direttiva per la federazione con la Federazione Apollo. Lo script inizia creando un file Genitore classe e assegnazione della [Chiave] E [ID] attribuisce ai suoi campi. Queste proprietà sono importanti per informare HotChocolate di contrassegnare il id campo come identificatore univoco dell'entità. Ciò è fondamentale quando si crea un servizio GraphQL federato in cui le entità possono essere condivise tra diversi servizi. Contrassegnare questo campo consente al servizio GraphQL di risolvere l'entità nelle query federate.

IL Risolutore di riferimento anche la funzione è una componente essenziale dello script. Questa funzione statica consente a HotChocolate di risolvere l'entità cercando il file Genitore oggetto in un repository. IL Repository genitore è registrato con il server GraphQL e il file Ottenere Il metodo recupera un genitore tramite il suo id. Nel codice bootstrap, il .AddQueryType l'istruzione registra il file Domanda oggetto, che viene utilizzato per eseguire query GraphQL. RegisterService consente di inserire dipendenze come ParentRepository nei risolutori GraphQL. Questo design semplifica il recupero dei dati preservando una chiara separazione delle preoccupazioni.

Il secondo esempio adotta un approccio schema-first, utilizzando GraphQL SDL (Schema Definition Language) per definire il file @chiave direttiva all'interno dello schema. Questa soluzione è particolarmente efficace per i team che hanno già familiarità con la sintassi SDL di GraphQL. In questo esempio, il @chiave la direttiva si applica a Genitore tipo, indicando chiaramente il id campo come identificatore univoco. L'uso dello schema-first consente agli sviluppatori di avere un maggiore controllo su come viene creato lo schema GraphQL e di modificarlo senza dover accedere al codice C#, rendendolo un'opzione più flessibile per i team più grandi.

Infine, il componente di test unitario verifica che il codice funzioni come previsto. Utilizzando il framework di test xUnit, Assert.The Contiene Il comando garantisce che lo schema risultante includa il file @chiave direttiva. Questo test convalida lo schema per la presenza di @chiave direttiva, confermando che il servizio è configurato correttamente per la federazione. Il test unitario è una procedura consigliata per garantire che le modifiche allo schema GraphQL o ai metodi di risoluzione non interrompano la funzionalità, soprattutto in un sistema federato in cui più servizi devono operare insieme senza problemi.

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

Miglioramento di GraphQL con Apollo Federation e HotChocolate

L'utilizzo di GraphQL con HotChocolate in un ambiente federato richiede un'unione di schemi ben strutturata. Apollo Federation consente agli sviluppatori di partizionare gli schemi tra diversi servizi mantenendo un'interfaccia uniforme. Utilizzando il @chiave direttiva con HotChocolate, puoi specificare come le entità GraphQL vengono risolte su diversi servizi. Ciò rende la tua API più modulare e scalabile, il che è particolarmente vantaggioso nei grandi sistemi distribuiti in cui più team controllano diversi aspetti dello schema GraphQL.

In un tipico schema federato, entità come Genitore possono esistere in molti servizi. La Federazione Apollo utilizza il @chiave direttiva per identificare in modo univoco un'entità in base a un campo specificato, come id. Il supporto di HotChocolate per Apollo Federation garantisce che il tuo servizio si integri facilmente in un'infrastruttura più grande. Oltre a impostare le chiavi, puoi utilizzare direttive di federazione come as @estende O @esterno per gestire i campi dati dispersi su diversi microservizi, fornendo maggiore flessibilità per la configurazione di GraphQL.

Un altro fattore chiave durante l'utilizzo di HotChocolate è l'ottimizzazione delle prestazioni. Il recupero eccessivo dei dati è un problema comune con le API GraphQL, in particolare nei contesti federati. Utilizzando i risolutori corretti, come ad esempio Risolutore di riferimento descritto nei casi precedenti, garantisce che la tua API fornisca solo i dati richiesti senza ricerche eccessive. Inoltre, HotChocolate supporta algoritmi avanzati di batching di query e memorizzazione nella cache, che possono aumentare la velocità di risposta dell'API e l'efficienza in uno schema federato.