web-dev-qa-db-fra.com

comment définir une relation plusieurs-à-plusieurs dans la mutation graphql?

Il se peut que je manque quelque chose, mais je ne trouve aucune information sur la documentation Apollo concernant la manière de définir une relation plusieurs à plusieurs lors de la création d'une nouvelle entrée.

Lorsque la relation est un-à-plusieurs, il suffit simplement de définir l'ID du côté de la relation dans l'objet à plusieurs côtés.

Mais supposons que je travaille avec Books and Authors, comment pourrais-je écrire une requête graphql qui crée un livre pour un (ou plusieurs?) Auteurs?

graphqlapolloreact-apollo
6
vgrafe

Cela devrait probablement se produire au niveau de la couche API sur le serveur GraphQL (c'est-à-dire un schéma). Pour les relations plusieurs à plusieurs, vous devez avoir un type "jointure" pour désigner la relation BookAuthor plusieurs-à-plusieurs, puis ajouter une entrée à ce type de jointure.

Dans ce cas, vous aurez essentiellement un type appelé Book, un autre appelé Author et enfin un autre appelé BookAuthor. Et vous pouvez ajouter quelques mutations pour pouvoir gérer cette relation. Peut-être ...

  • addToBookAuthorConnection
  • updateBookAuthorConnection
  • removeFromBookAuthorConnection

Il s'agit d'une configuration conventionnelle utilisant une API conforme à la spécification de relais. Vous pouvez en savoir plus sur la structure de votre API pour les relations plusieurs à plusieurs ici .

Ensuite, il vous suffit d'appeler la mutation addToBookAuthorConnection d'Apollo à la place pour pouvoir ajouter à cette connexion plusieurs à plusieurs sur votre interface.

J'espère que cela t'aides!

4
vince

Si vous utilisez apollo graph server avec une à plusieurs relations, les fichiers connecteurs.js, resolvers.js et schema.js sont au format indiqué

schema.js

const typeDefinitions = `



type Author {

  authorId: Int
  firstName: String
  lastName: String
  posts: [Post]

}

type Post {

  postId: Int
  title: String 
  text: String
  views: Int
  author: Author

}

input postInput{
  title: String 
  text: String
  views: Int
}


type Query {

  author(firstName: String, lastName: String): [Author]
  posts(postId: Int, title: String, text: String, views: Int): [Post]

}



type Mutation {

createAuthor(firstName: String, lastName: String, posts:[postInput]): Author

updateAuthor(authorId: Int, firstName: String, lastName: String, posts:[postInput]): String

}


schema {
  query: Query
  mutation:Mutation
}
`;

export default [typeDefinitions];

résolvers.js

import { Author } from './connectors';
import { Post } from './connectors';


const resolvers = {

  Query: {
    author(_, args) {
      return Author.findAll({ where: args });
    },
    posts(_, args) {
      return Post.findAll({ where: args });
    }
  },

  Mutation: {

    createAuthor(_, args) {
      console.log(args)
      return Author.create(args, {
        include: [{
          model: Post,
        }]
      });
    },

    updateAuthor(_, args) {

      var updateProfile = { title: "name here" };
      console.log(args.authorId)
      var filter = {
        where: {
          authorId: args.authorId
        },
        include: [
          { model: Post }
        ]
      };
      Author.findOne(filter).then(function (product) {
        Author.update(args, { where: { authorId: args.authorId } }).then(function (result) {
          product.posts[0].updateAttributes(args.posts[0]).then(function (result) {
            //return result;
          })
        });
      })
      return "updated";
    },

  },


  Author: {
    posts(author) {
      return author.getPosts();
    },
  },
  Post: {
    author(post) {
      return post.getAuthor();
    },
  },
};

export default resolvers;

connecteurs.js

import rp from 'request-promise';
var Sequelize = require('sequelize');
var db = new Sequelize('test', 'postgres', 'postgres', {
  Host: '192.168.1.168',
  dialect: 'postgres',

  pool: {
    max: 5,
    min: 0,
    idle: 10000
  }

});


const AuthorModel = db.define('author', {
  authorId: { type: Sequelize.INTEGER, primaryKey: true, autoIncrement: true, field: "author_id" },
  firstName: { type: Sequelize.STRING, field: "first_name" },
  lastName: { type: Sequelize.STRING, field: "last_name" },
},{
        freezeTableName: false,
        timestamps: false,
        underscored: false,
        tableName: "author"
    });


const PostModel = db.define('post', {
    postId: { type: Sequelize.INTEGER, primaryKey: true, autoIncrement: true, field: "post_id" },
  text: { type: Sequelize.STRING },
  title:  { type: Sequelize.STRING },
  views: { type: Sequelize.INTEGER },
},{
        freezeTableName: false,
        timestamps: false,
        underscored: false,
        tableName: "post"
    });


AuthorModel.hasMany(PostModel, {
    foreignKey: 'author_id'
});
PostModel.belongsTo(AuthorModel, {
    foreignKey: 'author_id'
});

const Author = db.models.author;
const Post = db.models.post;

export { Author, Post };
1
Noyal