GraphQL requêtes avec des tables de jointure

Je suis en train d'apprendre GraphQL j'ai donc construit un petit projet. Disons que j'ai 2 modèles, User et Comment.

const Comment = Model.define('Comment', {

  content: {
    type: DataType.TEXT,
    allowNull: false,
    validate: {
      notEmpty: true,
    },
  },

});

const User = Model.define('User', {

  name: {
    type: DataType.STRING,
    allowNull: false,
    validate: {
      notEmpty: true,
    },
  },

  phone: DataType.STRING,

  picture: DataType.STRING,

});

Les relations sont 1:de nombreux, où un utilisateur peut avoir plusieurs commentaires.

J'ai construit le schéma comme ceci:

const UserType = new GraphQLObjectType({
  name: 'User',
  fields: () => ({
    id: {
      type: GraphQLString
    },
    name: {
      type: GraphQLString
    },
    phone: {
      type: GraphQLString
    },
    comments: {
      type: new GraphQLList(CommentType),
      resolve: user => user.getComments()
    }
  })
});

Et la requête:

const user = {
  type: UserType,
  args: {
    id: {
      type: new GraphQLNonNull(GraphQLString)
    }
  },
  resolve(_, {id}) => User.findById(id)
};

L'exécution de la requête d'un utilisateur et de ses commentaires est fait avec 1 demande, comme suit:

{
  User(id:"1"){
    Comments{
      content
    }
  }
}

Que je comprends, le client devra obtenir les résultats à l'aide de 1 de la requête, c'est l'avantage à l'aide de GraphQL. Mais le serveur va exécuter 2 requêtes, l'une pour l'utilisateur et un autre pour ses commentaires.

Ma question est, quelles sont les meilleures pratiques pour la construction de la GraphQL schéma et les types et la combinaison de jointure entre les tables, de sorte que le serveur peut également exécuter la requête avec 1 demande?

InformationsquelleAutor itaied | 2016-12-03
  1. 12

    Le concept vous référant à un est appelé le traitement par lots. Il existe plusieurs bibliothèques qui offrent ce. Par exemple:

    • Dataloader: générique utilitaire maintenu par Facebook "fournit une API cohérente sur les différents backends et de réduire les demandes de ces backends via le traitement par lots et la mise en cache"

    • rejoignez-monstre: "Un GraphQL-à-requête SQL couche d'exécution pour le lot récupération de données."

    • Si vous préférez la vidéo, voici un parler de rejoindre monstre: youtube.com/watch?v=Y7AdMIuXOgs 🙂
    • Merci pour votre post. Lequel choisiriez-vous? D'une part j'ai facebook et 1800 étoiles de la bibliothèque de ce lot quelques demandes, mais d'un autre côté j'ai une bibliothèque de lot tout pour 1 requête.
    • Nous avons fait de bonnes expériences avec Dataloader à Graphcool, quand nous avons été en cours d'exécution d'un nœud GraphQL backend avec graphql-js. Ne pouvez pas partager une expérience sur la jointure de monstre. Je pense qu'ils diffèrent légèrement dans les caractéristiques et l'utilisation de sorte que vous devez de l'essayer, je suppose 🙂
    InformationsquelleAutor marktani
  2. 4

    À quiconque de l'utiliser .NET et le GraphQL pour .NET paquet, j'ai fait une extension de la méthode qui convertit le GraphQL Requête dans le Cadre de l'Entité Comprend.

    public static class ResolveFieldContextExtensions
{
    public static string GetIncludeString(this ResolveFieldContext<object> source)
    {
        return string.Join(',', GetIncludePaths(source.FieldAst));
    }

    private static IEnumerable<Field> GetChildren(IHaveSelectionSet root)
    {
        return root.SelectionSet.Selections.Cast<Field>()
                                           .Where(x => x.SelectionSet.Selections.Any());
    }

    private static IEnumerable<string> GetIncludePaths(IHaveSelectionSet root)
    {
        var q = new Queue<Tuple<string, Field>>();
        foreach (var child in GetChildren(root))
            q.Enqueue(new Tuple<string, Field>(child.Name.ToPascalCase(), child));

        while (q.Any())
        {
            var node = q.Dequeue();
            var children = GetChildren(node.Item2).ToList();
            if (children.Any())
            {
                foreach (var child in children)
                    q.Enqueue(new Tuple<string, Field>
                                  (node.Item1 + "." + child.Name.ToPascalCase(), child));

            }
            else
            {
                yield return node.Item1;
            }
        }}}

    Permet de dire que nous avons la requête suivante: 

    query {
  getHistory {
    id
    product {
      id
      category {
        id
        subCategory {
          id
        }
        subAnything {
          id
        }
      }
    }
  }
}

    Nous pouvons créer une variable dans la section "résolution" de la méthode du champ:

    var include = context.GetIncludeString();

    qui génère la chaîne suivante:

    "Product.Category.SubCategory,Product.Category.SubAnything"

    et le transmettre à l'Entité Cadre:

    public Task<TEntity> Get(TKey id, string include)
{
    var query = Context.Set<TEntity>();
    if (!string.IsNullOrEmpty(include))
    {
        query = include.Split(',', StringSplitOptions.RemoveEmptyEntries)
                       .Aggregate(query, (q, p) => q.Include(p));
    }
    return query.SingleOrDefaultAsync(c => c.Id.Equals(id));
}
    InformationsquelleAutor ceferrari