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 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 pour décorer des types d'objets à l'aide de directif. Nous examinerons également des exemples particuliers utilisant du code C# pour construire un simple 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 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 et 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.

Commande	Exemple d'utilisation
	Dans HotChocolate, cette commande décore un type d'objet à l'aide du directif. Il définit quel champ servira d'identifiant unique du type lors des relations avec la Fédération Apollo.
	Lorsqu'il est appliqué à une méthode, cet attribut demande à HotChocolate d'utiliser cette méthode comme résolution pour les types fédérés. Il permet de récupérer des données pertinentes dans les services fédérés via des références externes.
	Cette commande configure la prise en charge d'Apollo Federation dans le serveur HotChocolate GraphQL. Il est nécessaire d'activer les fonctionnalités de schéma fédéré, telles que directif.
	Enregistre un service, tel que , dans le conteneur GraphQL DI. Cela vous permet d'injecter des services directement dans le résolveur GraphQL.
	Dans le modèle SDL, cette directive spécifie le champ clé principal de la fédération. Pour activer la résolution d'entités interservices, les types d'objet doivent avoir l'attribut directif.
	Exécute de manière asynchrone une requête GraphQL, couramment utilisée dans les tests unitaires pour garantir que le schéma et les directives, telles que , sont correctement mis en œuvre.
	Cette fonctionnalité est utilisée pour injecter des dépendances telles que des référentiels ou des services dans les arguments de la méthode de résolution GraphQL, permettant ainsi la récupération de services dans HotChocolate.
	La commande de test unitaire de XUnit est utilisée pour garantir que certaines chaînes ou directives, comme la directive, sont inclus dans le schéma GraphQL généré lors des tests.

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

Le premier script explique comment implémenter le 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 classe et attribuer le et [IDENTIFIANT] attributs à ses champs. Ces propriétés sont importantes pour informer HotChocolate afin de marquer le 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 la fonction est également un élément essentiel du script. Cette fonction statique permet à HotChocolate de résoudre l'entité en recherchant le objet dans un référentiel. Le est enregistré auprès du serveur GraphQL et le Obtenir La méthode récupère un parent par son . Dans le code d'amorçage, le l'instruction enregistre le 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 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 à type, indiquant clairement le 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 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 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 peut exister dans de nombreux services. La Fédération Apollo utilise le directive pour identifier de manière unique une entité en fonction d'un champ spécifié, comme . 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 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 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é.

1. Comment Apollo Federation profite-t-il au développement de GraphQL ?
2. Apollo Federation vous permet de diviser les schémas GraphQL en plusieurs services, chacun étant responsable d'une section du schéma, tout en conservant une API cohérente.
3. Quel est le directive utilisée dans HotChocolate ?
4. Le La directive crée un identifiant unique pour une entité, lui permettant d'être résolue sur plusieurs services GraphQL.
5. Puis-je utiliser et attributs ensemble dans HotChocolate ?
6. Oui, le la propriété est utilisée pour la fédération, et spécifie le champ comme identifiant dans le schéma.
7. Qu'est-ce que faire dans HotChocolate ?
8. Enregistre un service, tel qu'un référentiel, auprès du serveur GraphQL, permettant l'injection de dépendances dans vos résolveurs.
9. Comment tester les schémas GraphQL avec HotChocolate ?
10. HotChocolate permet de tester les schémas à l'aide de tests unitaires en appelant le schéma et en vérifiant les directives telles que dans le résultat obtenu.

Utiliser HotChocolate directive garantit que votre fédération est correctement configuré pour Apollo Federation. Cette approche améliore la gestion des types d'objets et permet une résolution d'entités interservices.

Configurer votre serveur GraphQL avec HotChocolate et utiliser des directives comme simplifie la création de grandes API distribuées. Cette stratégie vous permet d'étendre vos services plus facilement tout en conservant une assemblage de schémas cohérent et hautes performances.