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. 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 att dekorera objekttyper med hjälp av direktiv. Vi kommer också att titta på särskilda exempel som använder C#-kod för att konstruera en enkel 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, 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 och paket. Med rätt konfiguration kan du enkelt tillämpa direktiv och säkerställa korrekt schemafederation för dina tjänster.

Kommando	Exempel på användning
	I HotChocolate dekorerar detta kommando en objekttyp med hjälp av direktiv. Den definierar vilket fält som kommer att fungera som typens unika identifierare när den hanterar Apollo Federation.
	När det tillämpas på en metod instruerar detta attribut HotChocolate att använda den metoden som en upplösning för federerade typer. Det tillåter hämtning av relevant data i federerade tjänster via externa referenser.
	Detta kommando konfigurerar Apollo Federation-stödet i HotChocolate GraphQL-servern. Det är nödvändigt att aktivera federerade schemafunktioner, såsom direktiv.
	Registrerar en tjänst, som t.ex , i GraphQL DI-behållaren. Detta gör att du kan injicera tjänster direkt i GraphQL-resolvern.
	I SDL-modellen specificerar detta direktiv huvudnyckelfältet för federation. För att möjliggöra upplösning av entitetsöverskridande tjänster måste objekttyperna ha direktiv.
	Exekverar asynkront en GraphQL-fråga, som vanligtvis används i enhetstester för att säkerställa att schemat och direktiven, som t.ex. , är korrekt implementerade.
	Den här funktionen används för att injicera beroenden som arkiv eller tjänster i GraphQL-resolvermetodens argument, vilket möjliggör tjänsthämtning i HotChocolate.
	XUnits enhetstestkommando används för att säkerställa att vissa strängar eller direktiv, som t.ex direktiv, ingår i det genererade GraphQL-schemat under tester.

Förstå nyckeldirektivens roll i varmchoklad

Det första skriptet förklarar hur man implementerar 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 klass och tilldela och [ID] attribut till dess områden. Dessa egenskaper är viktiga för att informera HotChocolate att markera 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 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 objekt i ett arkiv. De är registrerad på GraphQL-servern och Få metoden hämtar en förälder genom sin . I bootstrap-koden är instruktion registrerar 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 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å typ, som tydligt anger 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 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 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 kan finnas i många tjänster. Apollo Federation använder direktiv för att unikt identifiera en enhet baserat på ett specificerat fält, som . 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 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 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.

1. Hur gynnar Apollo Federation utvecklingen av GraphQL?
2. Apollo Federation låter dig dela upp GraphQL-scheman i många tjänster, som var och en ansvarar för en del av schemat, men som fortfarande har ett konsekvent API.
3. Vad är direktiv används för i HotChocolate?
4. De direktiv skapar en unik identifierare för en enhet, vilket gör att den kan lösas över flera GraphQL-tjänster.
5. Kan jag använda och attribut tillsammans i HotChocolate?
6. Ja, den egendom används för federation, och anger fältet som en identifierare i schemat.
7. Vad gör göra i HotChocolate?
8. Registrerar en tjänst, till exempel ett arkiv, med GraphQL-servern, vilket möjliggör injektion av beroenden i dina resolvers.
9. Hur testar du GraphQL-scheman med HotChocolate?
10. HotChocolate möjliggör schematestning med hjälp av enhetstester genom att anropa schemat och söka efter direktiv som i det resulterande resultatet.

Använder HotChocolate's direktiv säkerställer att din federerade är lämpligt konfigurerad för Apollo Federation. Detta tillvägagångssätt förbättrar objekttypshanteringen och möjliggör lösning av entitetsöverskridande tjänster.

Konfigurera din GraphQL-server med HotChocolate och använda direktiv som förenklar byggandet av stora, distribuerade API:er. Denna strategi gör det möjligt för dig att utöka dina tjänster lättare samtidigt som du bibehåller konsekvent, högpresterande schemasömmar.