Hoe HotChocolate te gebruiken om de sleutelrichtlijn toe te passen op objecttypen in GraphQL

Objecttypen optimaliseren met sleutelrichtlijnen in HotChocolate

Wanneer u GraphQL met HotChocolate gebruikt, moet u mogelijk uw objecttypen uitbreiden met richtlijnen, zoals de @sleutel richtlijn, om compatibiliteit met Apollo Federation te garanderen. Dit is vooral belangrijk voor federatieve schema's, waarin sleutels entiteiten in verschillende services identificeren. Het is van cruciaal belang dat u begrijpt hoe u uw objecttypen op de juiste manier kunt ontwerpen met deze richtlijnen.

Dit artikel laat zien hoe u het kunt gebruiken Warme chocolademelk om objecttypen te versieren met behulp van de @sleutel richtlijn. We zullen ook kijken naar specifieke voorbeelden waarbij C#-code wordt gebruikt om een ​​eenvoudig Ouder klasse en hoe u het geproduceerde GraphQL-schema kunt wijzigen. De nadruk zal liggen op de daadwerkelijke acties die u kunt ondernemen om deze functionaliteit te creëren.

Wanneer HotChocolate wordt gebruikt om GraphQL-objecttypen te construeren, wordt de @sleutel richtlijn wordt mogelijk niet onmiddellijk toegepast zoals verwacht. In plaats daarvan kan het schema een eenvoudige typestructuur opleveren die essentiële kenmerken mist die nodig zijn voor federatie. We bespreken hoe u dit kunt oplossen en ervoor zorgen dat uw schema naar verwachting presteert.

We behandelen ook cruciale configuratietaken, zoals het wijzigen van de configuratie van uw GraphQL-server en het gebruiken van de juiste Warme chocolademelk En Apollo Federatie pakketten. Met de juiste configuratie kunt u eenvoudig richtlijnen toepassen en zorgen voor een goede schemafederatie voor uw services.

De rol van belangrijke richtlijnen in HotChocolate begrijpen

In het eerste script wordt uitgelegd hoe u het @sleutel richtlijn met behulp van HotChocolate in C#. Dit script garandeert dat het gemaakte GraphQL-schema de @sleutel richtlijn voor federatie met Apollo Federation. Het script begint met het maken van een Ouder klasse en het toewijzen van de [Sleutel] En [ID] attributen aan zijn velden. Deze eigenschappen zijn van belang om HotChocolate te informeren over de markering Identiteitskaart veld als de unieke identificatie van de entiteit. Dit is cruciaal bij het creëren van een federatieve GraphQL-service waarin entiteiten over verschillende services kunnen worden gedeeld. Als u dit veld markeert, kan de GraphQL-service de entiteit in federatieve query's omzetten.

De ReferentieResolver functie is ook een essentieel onderdeel van het script. Met deze statische functie kan HotChocolate de entiteit oplossen door te zoeken naar de Ouder object in een repository. De OuderRepository is geregistreerd bij de GraphQL-server, en de Krijgen methode haalt een ouder op via zijn Identiteitskaart. In de bootstrapcode wordt de .AddQueryType instructie registreert de Vraag object, dat wordt gebruikt om GraphQL-query's uit te voeren. RegisterService maakt het mogelijk om afhankelijkheden zoals ParentRepository in GraphQL-resolvers te injecteren. Dit ontwerp vereenvoudigt het ophalen van gegevens, terwijl een duidelijke scheiding van zorgen behouden blijft.

Het tweede voorbeeld hanteert een schema-eerste benadering, waarbij gebruik wordt gemaakt van GraphQL SDL (Schema Definition Language) om de @sleutel richtlijn binnen het schema. Deze oplossing is vooral effectief voor teams die al bekend zijn met de SDL-syntaxis van GraphQL. In dit voorbeeld is de @sleutel richtlijn wordt toegepast op de Ouder type, met duidelijke vermelding van de Identiteitskaart veld als de unieke identificatie. Door schema-first te gebruiken, hebben ontwikkelaars meer controle over hoe het GraphQL-schema wordt gebouwd en kunnen ze dit wijzigen zonder dat ze naar C#-code hoeven te gaan, waardoor het een flexibelere optie wordt voor grotere teams.

Ten slotte valideert de unit-testcomponent dat de code presteert zoals bedoeld. Met behulp van het xUnit-testframework, de Assert.The Bevat opdracht zorgt ervoor dat het resulterende schema de @sleutel richtlijn. Deze test valideert het schema voor de aanwezigheid van de @sleutel richtlijn, waarmee wordt bevestigd dat de service correct is geconfigureerd voor federatie. Unit-testen zijn een best practice om ervoor te zorgen dat wijzigingen in uw GraphQL-schema of oplossermethoden de functionaliteit niet verstoren, vooral in een federatief systeem waar meerdere services naadloos moeten samenwerken.

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

Verbetering van GraphQL met Apollo Federation en HotChocolate

Het gebruik van GraphQL met HotChocolate in een federatieve omgeving vereist goed gestructureerde schema-stitching. Apollo Federation stelt ontwikkelaars in staat schema's over verschillende services te verdelen, terwijl een uniforme interface behouden blijft. Met behulp van de @sleutel richtlijn met HotChocolate kunt u opgeven hoe GraphQL-entiteiten voor verschillende services worden opgelost. Dit maakt uw API modulair en schaalbaarder, wat vooral gunstig is in grote, gedistribueerde systemen waar meerdere teams verschillende aspecten van het GraphQL-schema beheren.

In een typisch federatief schema kunnen entiteiten zoals Ouder kan bij veel diensten voorkomen. Apollo Federatie maakt gebruik van de @sleutel richtlijn om een ​​entiteit op unieke wijze te identificeren op basis van een opgegeven veld, zoals Identiteitskaart. De ondersteuning van HotChocolate voor Apollo Federation zorgt ervoor dat uw dienst moeiteloos integreert in een grotere infrastructuur. Naast het instellen van sleutels kunt u federatierichtlijnen gebruiken, zoals as @verlengt of @extern om gegevensvelden verspreid over verschillende microservices te beheren, wat meer flexibiliteit biedt voor uw GraphQL-installatie.

Een andere belangrijke factor bij het gebruik van HotChocolate is prestatie-optimalisatie. Het overhalen van gegevens is een veelvoorkomend probleem bij GraphQL API's, vooral in federatieve contexten. Met behulp van de juiste solvers, zoals de ReferentieResolver zoals beschreven in eerdere gevallen, garandeert dat uw API alleen de benodigde gegevens levert zonder overmatig zoeken. Bovendien ondersteunt HotChocolate geavanceerde batching- en caching-algoritmen voor query's, die de API-responssnelheden en efficiëntie in een federatief schema kunnen verhogen.