Comparaison des paramètres parents utilisés dans le résolveur Apollo GraphQL par rapport à l'étape $lookup dans l'agrégation MongoDB pour rejoindre les modèles Mongoose

Question

Je développe une application backend utilisant Apollo GraphQL et Mongoose. J'ai deux modèles : User et Post, qui ont une relation un-à-plusieurs (un utilisateur peut avoir plusieurs publications, mais une publication appartient à un utilisateur).

Je souhaite interroger le champ Utilisateur dans un schéma GraphQL pour obtenir un utilisateur par ID utilisateur et toutes les publications appartenant à cet utilisateur. Je souhaite également interroger le champ auteur dans mon type de message pour obtenir l'utilisateur qui a écrit le message.

J'ai appris qu'il existe deux façons de joindre des données de différentes collections dans MongoDB : en utilisant le paramètre parent dans le résolveur Apollo GraphQL ou en utilisant l'étape $lookup dans un agrégat MongoDB.

Le paramètre parent est un objet contenant les résultats renvoyés par l'analyseur sur le champ parent. Les paramètres parents peuvent être utilisés pour accéder aux données d’un champ ou d’un type parent et les transmettre à un champ ou un type enfant. Par exemple, je peux l'utiliser pour rejoindre un modèle de mangouste comme celui-ci :

type Utilisateur {
  je l'ai fait!
  nom : chaîne
  messages : [Message]
}

tapez Post {
  je l'ai fait!
  titre : chaîne
  auteur : Utilisateur
}

tapez Requête {
  utilisateur(id: ID!): Utilisateur
}

résolveurs const = {
  Utilisateur: {
    messages (parent, arguments, contexte) {
      return context.db.Post.find({ author: parent.id });
    },
  },
};
L'étape $lookup est une étape de pipeline d'agrégation qui effectue une jointure externe gauche avec une autre collection dans la même base de données. L'étape $lookup peut être utilisée pour fusionner les données de plusieurs collections en un seul jeu de résultats. Par exemple, je peux l'utiliser pour rejoindre un modèle comme celui-ci : 
db.posts
  .agrégat([
    {
      $recherche : {
        de : "utilisateurs",
        localField : "auteur",
        champétranger : "_id",
        comme : "auteur",
      },
    },
  ])
  .toArray((erreur, messages) => {
    console.log(messages);
  });
Je ne sais pas lequel utiliser pour ma candidature. Je voulais choisir une option plus efficace, évolutive et maintenable. 
Quelles sont les principales différences et compromis entre l'utilisation des paramètres parents dans les résolveurs Apollo GraphQL et l'utilisation de l'étape $lookup dans les agrégations MongoDB pour rejoindre les modèles Mongoose ? 

Answer 1

Je recommande la première technique - elle est définitivement plus propre et probablement plus rapide. Vous devez vous assurer d'indexer le champ author - tout comme vous indexez les clés étrangères dans un RDB.

Answer 2

Il existe quelques différences entre ces deux méthodes

Utilisez un analyseur

Je trouve cette approche plus intuitive et lisible, et donc plus facile à maintenir, notamment pour les requêtes complexes

Cependant, il n'est peut-être pas le plus efficace lorsqu'il s'agit de traiter de grandes quantités de données, car il effectuera des appels supplémentaires à la base de données pour chaque champ imbriqué. Cela peut devenir un goulot d'étranglement en termes de performances lorsque vous traitez un grand nombre de requêtes imbriquées complexes.

Utilisez $lookup

D'un autre côté, les opérations $lookup sont généralement plus performantes car elles utilisent un seul appel à la base de données pour se connecter et récupérer les données.

Cependant, à mesure que la complexité des requêtes augmente, les opérations $lookup peuvent devenir complexes et difficiles à lire et à maintenir. Cela peut nécessiter plus de connaissances du langage de requête MongoDB et peut ne pas être aussi simple et facile à utiliser que l'approche analyseur. Des agrégats mal écrits peuvent entraîner des problèmes de performances, alors soyez absolument sûr de ce que vous faites.

Donc, dans votre exemple, cela ne me dérangerait pas d'utiliser l'approche parseur, la première approche serait plus facile à lire/améliorer/maintenir même si l'utilisation de l'agrégation est plus rapide.

J'espère que cela aide :)