Cum să utilizați HotChocolate pentru a aplica directiva cheie la tipurile de obiecte din GraphQL

Optimizarea tipurilor de obiecte cu directiva cheie în HotChocolate

Când utilizați GraphQL cu HotChocolate, poate fi necesar să vă extindeți tipurile de obiecte cu directive, cum ar fi @cheie directivă, pentru a asigura compatibilitatea cu Federația Apollo. Acest lucru este deosebit de important pentru schemele federate, în care cheile identifică entitățile din mai multe servicii. Înțelegerea modului de proiectare adecvat a tipurilor de obiecte cu aceste directive este esențială.

Acest articol va arăta cum se utilizează Ciocolată fierbinte pentru a decora tipuri de obiecte folosind @cheie directivă. De asemenea, ne vom uita la exemple particulare care utilizează cod C# pentru a construi un simplu Mamă clasa și cum să schimbați schema GraphQL produsă. Accentul va fi pus pe acțiunile reale pe care le puteți întreprinde pentru a crea această funcționalitate.

Când utilizați HotChocolate pentru a construi tipuri de obiecte GraphQL, @cheie directiva poate să nu fie aplicată instantaneu, așa cum era de așteptat. În schimb, schema poate produce o structură de tip simplă care nu are caracteristicile critice necesare pentru federație. Vom analiza cum să rezolvăm acest lucru și vom face ca schema să funcționeze conform așteptărilor.

Vom acoperi, de asemenea, sarcini cruciale de configurare, cum ar fi modificarea configurației serverului GraphQL și utilizarea dreptului Ciocolată fierbinte şi Federația Apollo pachete. Cu o configurație adecvată, puteți aplica cu ușurință directive și puteți asigura o federație adecvată a schemelor pentru serviciile dvs.

Înțelegerea rolului directivelor cheie în HotChocolate

Primul script explică cum se implementează @cheie directivă folosind HotChocolate în C#. Acest script garantează că schema GraphQL creată conține @cheie directivă pentru federație cu Apollo Federation. Scriptul începe prin crearea unui Mamă clasa si atribuirea [Cheie] şi [ID] atribute câmpurilor sale. Aceste proprietăți sunt importante pentru a informa HotChocolate să marcheze id câmp ca identificator unic al entității. Acest lucru este crucial atunci când se creează un serviciu GraphQL federat în care entitățile pot fi partajate în mai multe servicii. Marcarea acestui câmp permite serviciului GraphQL să rezolve entitatea în interogări federate.

The ReferenceResolver funcția este, de asemenea, o componentă esențială a scriptului. Această funcție statică permite HotChocolate să rezolve entitatea căutând Mamă obiect într-un depozit. The ParentRepository este înregistrat cu serverul GraphQL și Obţine metoda regăsește un părinte prin intermediul acestuia id. În codul bootstrap, .AddQueryType instrucțiunea înregistrează Interogare obiect, care este folosit pentru a executa interogări GraphQL. RegisterService permite injectarea de dependențe precum ParentRepository în rezolutoarele GraphQL. Acest design simplifică recuperarea datelor, păstrând în același timp o separare clară a preocupărilor.

Al doilea exemplu adoptă o abordare bazată pe schema, utilizând GraphQL SDL (Schema Definition Language) pentru a defini @cheie directivă în cadrul schemei. Această soluție este eficientă în special pentru echipele care sunt deja familiarizate cu sintaxa SDL a GraphQL. În acest exemplu, @cheie directiva se aplică la Mamă tip, indicând clar id câmp ca identificator unic. Utilizarea schema-first permite dezvoltatorilor să aibă mai mult control asupra modului în care este construită schema GraphQL și să o modifice fără a fi nevoie să intre în codul C#, făcându-l o opțiune mai flexibilă pentru echipele mai mari.

În cele din urmă, componenta de testare unitară validează dacă codul funcționează conform intenției. Folosind cadrul de testare xUnit, Assert.The Contains comanda asigură că schema rezultată include @cheie directivă. Acest test validează schema pentru prezența @cheie directivă, confirmând că serviciul este configurat corect pentru federație. Testarea unitară este cea mai bună practică pentru a vă asigura că modificările aduse schemei GraphQL sau metodelor de rezolvare nu perturbă funcționalitatea, în special într-un sistem federat în care mai multe servicii trebuie să funcționeze împreună fără probleme.

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

Îmbunătățirea GraphQL cu Apollo Federation și HotChocolate

Utilizarea GraphQL cu HotChocolate într-un mediu federat necesită o schemă bine structurată. Apollo Federation permite dezvoltatorilor să partiționeze scheme în mai multe servicii, menținând în același timp o interfață uniformă. Folosind @cheie directivă cu HotChocolate, puteți specifica modul în care entitățile GraphQL sunt rezolvate în mai multe servicii. Acest lucru face API-ul dvs. mai modular și scalabil, ceea ce este benefic în special în sistemele mari, distribuite, în care mai multe echipe controlează diferite aspecte ale schemei GraphQL.

Într-o schemă federală tipică, entități precum Mamă poate exista în multe servicii. Federația Apollo folosește @cheie directivă pentru a identifica în mod unic o entitate pe baza unui câmp specificat, cum ar fi id. Suportul HotChocolate pentru Apollo Federation asigură că serviciul dumneavoastră se integrează fără efort într-o infrastructură mai mare. Pe lângă setarea cheilor, puteți utiliza directive de federație precum as @se extinde sau @extern pentru a gestiona câmpuri de date dispersate pe mai multe microservicii, oferind o mai mare flexibilitate pentru configurarea GraphQL.

Un alt factor cheie în timpul utilizării HotChocolate este optimizarea performanței. Preluarea excesivă a datelor este o problemă comună cu API-urile GraphQL, în special în contexte federate. Folosind rezolutoarele corecte, cum ar fi ReferenceResolver descris în cazuri anterioare, garantează că API-ul dvs. furnizează numai datele necesare fără căutări excesive. În plus, HotChocolate acceptă algoritmi avansați de loturi de interogări și de stocare în cache, care pot crește vitezele de răspuns API și eficiența într-o schemă federată.