Hur man använder HotChocolate för att tillämpa nyckeldirektivet på objekttyper i GraphQL

Optimera objekttyper med nyckeldirektiv i varmchoklad

När du använder GraphQL med HotChocolate kan du behöva utöka dina objekttyper med direktiv, t.ex. @nyckel direktiv, för att säkerställa kompatibilitet med Apollo Federation. Detta är särskilt viktigt för federerade scheman, där nycklar identifierar enheter över flera tjänster. Det är viktigt att förstå hur du utformar dina objekttyper på lämpligt sätt med dessa direktiv.

Den här artikeln kommer att visa hur du använder Varm Choklad att dekorera objekttyper med hjälp av @nyckel direktiv. Vi kommer också att titta på särskilda exempel som använder C#-kod för att konstruera en enkel Förälder klass och hur man ändrar det producerade GraphQL-schemat. Tonvikten kommer att ligga på de faktiska åtgärder du kan vidta för att skapa denna funktionalitet.

När du använder HotChocolate för att konstruera GraphQL-objekttyper, @nyckel direktivet kanske inte tillämpas omedelbart som förväntat. Istället kan schemat producera en enkel typstruktur som saknar viktiga funktioner som krävs för federation. Vi går igenom hur du löser detta och får ditt schema att fungera som förväntat.

Vi kommer också att täcka viktiga konfigurationsuppgifter, som att ändra din GraphQL-serverkonfiguration och använda rätt Varm Choklad och Apolloförbundet paket. Med rätt konfiguration kan du enkelt tillämpa direktiv och säkerställa korrekt schemafederation för dina tjänster.

Förstå nyckeldirektivens roll i varmchoklad

Det första skriptet förklarar hur man implementerar @nyckel direktiv med HotChocolate i C#. Detta skript garanterar att det skapade GraphQL-schemat innehåller @nyckel direktiv för förbund med Apollo Federation. Skriptet börjar med att skapa en Förälder klass och tilldela [Nyckel] och [ID] attribut till dess områden. Dessa egenskaper är viktiga för att informera HotChocolate att markera id fältet som enhetens unika identifierare. Detta är avgörande när du skapar en federerad GraphQL-tjänst där enheter kan delas mellan flera tjänster. Genom att markera detta fält kan GraphQL-tjänsten lösa entiteten i federerade frågor.

De ReferenceResolver funktion är också en viktig komponent i skriptet. Denna statiska funktion gör det möjligt för HotChocolate att lösa entiteten genom att söka efter Förälder objekt i ett arkiv. De ParentRepository är registrerad på GraphQL-servern och Få metoden hämtar en förälder genom sin id. I bootstrap-koden är .AddQueryType instruktion registrerar Fråga objekt, som används för att exekvera GraphQL-frågor.RegisterService tillåter injicering av beroenden som ParentRepository i GraphQL-resolvers. Denna design förenklar datahämtning samtidigt som en tydlig åtskillnad av problem bevaras.

Det andra exemplet tar ett schema-första tillvägagångssätt och använder GraphQL SDL (Schema Definition Language) för att definiera @nyckel direktiv inom schemat. Denna lösning är särskilt effektiv för team som redan är bekanta med GraphQL:s SDL-syntax. I det här exemplet är @nyckel direktivet tillämpas på Förälder typ, som tydligt anger id fältet som den unika identifieraren. Genom att använda schema-first kan utvecklare ha mer kontroll över hur GraphQL-schemat är byggt och ändra det utan att behöva gå in i C#-kod, vilket gör det till ett mer flexibelt alternativ för större team.

Slutligen validerar enhetstestningskomponenten att koden fungerar som avsett. Med hjälp av xUnit-testramverket, Assert.The Contains kommandot säkerställer att det resulterande schemat inkluderar @nyckel direktiv. Detta test validerar schemat för närvaron av @nyckel direktiv som bekräftar att tjänsten är korrekt konfigurerad för federation. Enhetstestning är en bästa praxis för att säkerställa att ändringar i ditt GraphQL-schema eller resolvermetoder inte stör funktionaliteten, särskilt i ett federerat system där flera tjänster måste fungera sömlöst tillsammans.

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

Förbättra GraphQL med Apollo Federation och HotChocolate

Att använda GraphQL med HotChocolate i en federerad miljö kräver välstrukturerade schemasömmar. Apollo Federation gör det möjligt för utvecklare att partitionera scheman över flera tjänster samtidigt som ett enhetligt gränssnitt bibehålls. Med hjälp av @nyckel direktiv med HotChocolate, kan du ange hur GraphQL-enheter löses över flera tjänster. Detta gör ditt API mer modulärt och skalbart, vilket är särskilt fördelaktigt i stora, distribuerade system där flera team kontrollerar olika aspekter av GraphQL-schemat.

I ett typiskt federerat schema kan enheter som t.ex Förälder kan finnas i många tjänster. Apollo Federation använder @nyckel direktiv för att unikt identifiera en enhet baserat på ett specificerat fält, som id. HotChocolates stöd för Apollo Federation säkerställer att din tjänst enkelt integreras i en större infrastruktur. Förutom att ställa in nycklar kan du använda federationsdirektiv som as @förlänger eller @extern att hantera datafält spridda över flera mikrotjänster, vilket ger större flexibilitet för din GraphQL-installation.

En annan nyckelfaktor när du använder HotChocolate är prestandaoptimering. Att överhämta data är ett vanligt problem med GraphQL API:er, särskilt i federerade sammanhang. Använda rätt resolvers, såsom ReferenceResolver beskrivits i tidigare instanser, garanterar att ditt API endast levererar den data som krävs utan överdrivna sökningar. Dessutom stöder HotChocolate avancerade frågebatch- och cachningsalgoritmer, vilket kan öka API-svarshastigheter och effektivitet i ett federerat schema.