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?
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!
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 };