requête graphql nodejs

GraphQL est un langage de requête qui peut être utilisé pour demander des données dans des API. Il s'agit d'un langage de requête fortement typé qui nous aide à définir les champs pouvant être demandés dans l'API et le type de chaque champ. GraphQL a été initialement développé par Facebook et est depuis open source et largement utilisé pour créer des applications Web.

Node.js est un environnement d'exécution JavaScript populaire qui nous permet d'écrire des applications côté serveur à l'aide de JavaScript. L'efficacité et l'écosystème robuste de Node.js le rendent idéal pour créer des API hautes performances. Il existe de nombreuses bibliothèques GraphQL dans Node.js qui rendent l'utilisation des API GraphQL très simple et efficace.

Cet article expliquera comment utiliser GraphQL pour interroger des données dans Node.js. Nous utiliserons une application simple basée sur Node.js et le framework Express pour interroger des données à l'aide de GraphQL.

Étape 1 : Créez une application Express simple et configurez GraphQL

Tout d'abord, nous devons créer une application Node.js. Utilisons le framework Express pour créer notre application. Avant de créer l'application, assurez-vous que Node.js et npm sont installés sur votre système. Nous pouvons vérifier si Node.js est installé en tapant la commande suivante dans le terminal :

node -v

Si vous avez installé Node.js avec succès, vous devriez voir le numéro de version installé.

Ensuite, créez un nouveau répertoire de projet dans le terminal et initialisez npm :

mkdir nodejs-graphql-demo
cd nodejs-graphql-demo
npm init -y

Maintenant, installons les dépendances nécessaires à l'aide de la commande suivante :

npm install express graphql express-graphql

Avant de continuer, comprenons ces dépendances en détail.

• Express : framework d'application Web, qui peut nous aider à créer des applications Web basées sur Node.js.
• GraphQL : langage de requête, qui peut être utilisé pour demander des données dans les API.
• express-graphql : middleware GraphQL pour le framework Express.

Ensuite, créons un nouveau fichier server.js dans le répertoire personnel du projet et ajoutons le contenu suivant :

const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { buildSchema } = require('graphql');

const app = express();

const schema = buildSchema(`
  type Query {
    message: String
  }
`);

const root = {
  message: () => 'Hello World!'
};

app.use('/graphql', graphqlHTTP({
  schema: schema,
  rootValue: root,
  graphiql: true
}));

const PORT = process.env.PORT || 5000;

app.listen(PORT, () => console.log(`Server started on port ${PORT}`));

Dans le code ci-dessus, nous importons d'abord les modules Express, graphqlHTTP et buildSchema. Ensuite, nous créons une instance Express et définissons un schéma de requête simple à l'aide de la fonction buildSchema. Notre modèle de requête contient un seul champ de requête appelé message et renvoie une chaîne.

Ensuite, nous définissons un objet JavaScript nommé root, qui contient une fonction de message qui renvoie "Hello World!" Dans GraphQL, cet objet est appelé objet résolveur racine. Nous définissons un middleware pour GraphQL et utilisons les objets de schéma et de résolution racine que nous venons de créer. Ce middleware fournira un service GraphQL sur le chemin acheminé vers /graphql, et l'option graphiql définie sur true activera l'interface GraphiQL.

Enfin, nous démarrons l'application en utilisant la méthode d'écoute de l'instance Express et écoutons sur le port 5000.

Étape 2 : Testez la requête GraphQL

Nous avons configuré avec succès le middleware GraphQL et nous pouvons maintenant tester nos requêtes. Utilisons Postman pour ce faire. Tout d’abord, nous devons installer et démarrer Postman. Démarrez Postman en entrant la commande suivante dans le terminal :

postman

Maintenant, créons une nouvelle requête POST et définissons l'URL sur http://localhost:5000/graphql. Dans le corps de la requête, ajoutez la requête suivante à l'éditeur de requêtes GraphQL :

query {
  message
}

Nous pouvons maintenant envoyer la requête et afficher la réponse. La réponse doit contenir ce qui suit :

{
    "data": {
        "message": "Hello World!"
    }
}

Comme vous pouvez le voir, nous avons réussi à obtenir la réponse de la requête GraphQL. Améliorons notre requête avec plus de champs et de types de requête.

Étape 3 : Ajouter plus de champs et de types de requête

Maintenant, élargissons notre modèle de requête pour inclure plus de champs et de types. Jetons un coup d'œil à l'exemple suivant :

const schema = buildSchema(`
  type Query {
    message: String
    number: Int
    person: Person
  }

  type Person {
    name: String
    age: Int
    address: Address
  }

  type Address {
    street: String
    city: String
    state: String
    country: String
  }
`);

const root = {
  message: () => 'Hello World!',
  number: () => 42,
  person: () => ({
    name: 'John Doe',
    age: 30,
    address: { 
      street: '123 Main St',
      city: 'Anytown',
      state: 'CA',
      country: 'USA'
    }
  })
};

Dans le code ci-dessus, nous avons ajouté un champ de requête entier appelé numéro, et un champ de requête appelé personne, qui renvoie un objet de type Personne. Nous définissons également les types Personne et Adresse.

Dans l'objet analyseur racine, nous définissons les fonctions correspondant aux nouveaux champs et types. Les champs message et numérique renvoient respectivement des chaînes et des entiers, tandis que le champ personne renvoie un objet Personne dont les champs et les valeurs sont définis par nos soins.

Maintenant, testons la nouvelle requête. Nous pouvons utiliser la requête suivante :

query {
  message
  number
  person {
    name
    age
    address {
      street
      city
      state
      country
    }
  }
}

La réponse doit contenir ce qui suit :

{
  "data": {
    "message": "Hello World!",
    "number": 42,
    "person": {
      "name": "John Doe",
      "age": 30,
      "address": {
        "street": "123 Main St",
        "city": "Anytown",
        "state": "CA",
        "country": "USA"
      }
    }
  }
}

Comme vous pouvez le voir, nous avons réussi à interroger les nouveaux champs et types. Vous pouvez ajouter plus de champs et de types selon vos besoins pour renvoyer des données plus utiles dans l'API.

Conclusion

Dans cet article, nous avons appris à interroger des données à l'aide de GraphQL dans Node.js. Nous avons créé une application simple basée sur le framework Express et utilisé le middleware Express et le module GraphQL pour interroger les données par programme. Nous avons également ajouté davantage de champs et de types de requête pour améliorer nos requêtes. GraphQL est un outil très puissant et utile qui nous aide à créer des API efficaces et évolutives.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!