Comment utiliser HotChocolate pour appliquer la directive clé aux types d'objets dans GraphQL

Optimisation des types d'objets avec la directive clé dans HotChocolate

Lorsque vous utilisez GraphQL avec HotChocolate, vous devrez peut-être étendre vos types d'objets avec des directives, telles que @clé directive, pour assurer la compatibilité avec Apollo Federation. Ceci est particulièrement important pour les schémas fédérés, dans lesquels les clés identifient les entités de plusieurs services. Comprendre comment concevoir correctement vos types d'objets avec ces directives est essentiel.

Cet article montrera comment utiliser Chocolat chaud pour décorer des types d'objets à l'aide de @clé directif. Nous examinerons également des exemples particuliers utilisant du code C# pour construire un simple Mère classe et comment modifier le schéma GraphQL produit. L'accent sera mis sur les actions réelles que vous pouvez entreprendre pour créer cette fonctionnalité.

Lorsque vous utilisez HotChocolate pour construire des types d'objets GraphQL, le @clé La directive pourrait ne pas être appliquée instantanément comme prévu. Au lieu de cela, le schéma peut produire une structure de type simple dépourvue des fonctionnalités essentielles requises pour la fédération. Nous verrons comment résoudre ce problème et faire en sorte que votre schéma fonctionne comme prévu.

Nous couvrirons également les tâches de configuration cruciales, telles que la modification de la configuration de votre serveur GraphQL et l'utilisation du bon Chocolat chaud et Fédération Apollo forfaits. Avec la configuration appropriée, vous pouvez facilement appliquer des directives et garantir une fédération de schéma appropriée pour vos services.

Comprendre le rôle des directives clés dans HotChocolate

Le premier script explique comment implémenter le @clé directive utilisant HotChocolate en C#. Ce script garantit que le schéma GraphQL créé contient le @clé directive de fédération avec Apollo Federation. Le script commence par créer un Mère classe et attribuer le [Clé] et [IDENTIFIANT] attributs à ses champs. Ces propriétés sont importantes pour informer HotChocolate afin de marquer le identifiant champ comme identifiant unique de l’entité. Ceci est crucial lors de la création d'un service GraphQL fédéré dans lequel les entités peuvent être partagées entre plusieurs services. Le marquage de ce champ permet au service GraphQL de résoudre l'entité dans les requêtes fédérées.

Le Résolveur de référence la fonction est également un élément essentiel du script. Cette fonction statique permet à HotChocolate de résoudre l'entité en recherchant le Mère objet dans un référentiel. Le Référentiel parent est enregistré auprès du serveur GraphQL et le Obtenir La méthode récupère un parent par son identifiant. Dans le code d'amorçage, le .AddQueryType l'instruction enregistre le Requête objet, qui est utilisé pour exécuter des requêtes GraphQL.RegisterService permet d'injecter des dépendances comme ParentRepository dans les résolveurs GraphQL. Cette conception simplifie la récupération des données tout en préservant une séparation claire des préoccupations.

Le deuxième exemple adopte une approche axée sur le schéma, en utilisant GraphQL SDL (Schema Definition Language) pour définir le @clé directive dans le schéma. Cette solution est particulièrement efficace pour les équipes déjà familiarisées avec la syntaxe SDL de GraphQL. Dans cet exemple, le @clé la directive est appliquée à Mère type, indiquant clairement le identifiant champ comme identifiant unique. L'utilisation du schéma d'abord permet aux développeurs d'avoir plus de contrôle sur la façon dont le schéma GraphQL est construit et de le modifier sans avoir à passer au code C#, ce qui en fait une option plus flexible pour les grandes équipes.

Enfin, le composant de test unitaire valide que le code fonctionne comme prévu. À l'aide du framework de test xUnit, Assert.The Contains La commande garantit que le schéma résultant inclut le @clé directif. Ce test valide le schéma de présence du @clé directive, confirmant que le service est correctement configuré pour la fédération. Les tests unitaires sont une bonne pratique pour garantir que les modifications apportées à votre schéma GraphQL ou à vos méthodes de résolution ne perturbent pas les fonctionnalités, en particulier dans un système fédéré où plusieurs services doivent fonctionner ensemble de manière transparente.

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

Améliorer GraphQL avec Apollo Federation et HotChocolate

L'utilisation de GraphQL avec HotChocolate dans un environnement fédéré nécessite une assemblage de schémas bien structuré. Apollo Federation permet aux développeurs de partitionner les schémas sur plusieurs services tout en conservant une interface uniforme. En utilisant le @clé avec HotChocolate, vous pouvez spécifier comment les entités GraphQL sont résolues sur plusieurs services. Cela rend votre API plus modulaire et évolutive, ce qui est particulièrement bénéfique dans les grands systèmes distribués où plusieurs équipes contrôlent différents aspects du schéma GraphQL.

Dans un schéma fédéré typique, des entités telles que Mère peut exister dans de nombreux services. La Fédération Apollo utilise le @clé directive pour identifier de manière unique une entité en fonction d'un champ spécifié, comme identifiant. La prise en charge par HotChocolate d'Apollo Federation garantit que votre service s'intègre sans effort dans une infrastructure plus vaste. En plus de définir des clés, vous pouvez utiliser des directives de fédération comme @étend ou @externe pour gérer les champs de données dispersés sur plusieurs microservices, offrant une plus grande flexibilité pour votre configuration GraphQL.

Un autre facteur clé lors de l’utilisation de HotChocolate est l’optimisation des performances. La récupération excessive de données est un problème courant avec les API GraphQL, en particulier dans les contextes fédérés. En utilisant les bons résolveurs, tels que le Résolveur de référence décrit dans les cas précédents, garantit que votre API fournit uniquement les données requises sans recherches excessives. De plus, HotChocolate prend en charge des algorithmes avancés de traitement par lots et de mise en cache des requêtes, qui peuvent augmenter la vitesse de réponse et l'efficacité des API dans un schéma fédéré.