Wie man viele-zu-viele-Beziehungen in der graphql-Mutation einstellt?

Question

Ich vermisse etwas, kann jedoch keine Informationen zu Apollo-Dokumenten finden, wie man beim Erstellen eines neuen Eintrags eine Viele-zu-Viele-Beziehung einstellt.

Wenn es sich bei der Beziehung um Eins-zu-viele handelt, ist es so einfach, die ID der einen Seite der Beziehung im Objekt mit vielen Seiten festzulegen.

Aber tun wir so, als würde ich mit Büchern und Autoren arbeiten, wie würde ich eine graphql-Abfrage schreiben, die ein Buch für einen (oder viele?) Autoren erstellt?

Answer 1

Dies sollte wahrscheinlich auf der API-Ebene auf dem GraphQL-Server (d. H. Schema) geschehen. Für Viele-zu-Viele-Beziehungen sollten Sie einen "Join" -Typ haben, um die 0:-Viele-zu-Viele-Beziehung zu bezeichnen, und dann einen Eintrag zu diesem Join-Typ hinzufügen.

Im Wesentlichen haben Sie dann eine Art namens Book, eine andere Author genannt, und schließlich eine weitere BookAuthor genannt. Und Sie können einige Mutationen hinzufügen, um diese Beziehung zu verwalten. Vielleicht ...

• addToBookAuthorConnection
• updateBookAuthorConnection
• removeFromBookAuthorConnection

Dies ist eine herkömmliche Einrichtung eine Relay-Spezifikation kompatible API. Sie können read more about how to structure your API for many-to-many relationships here.

Dann müssen Sie nur die Mutation addToBookAuthorConnection von Apollo aufrufen, um diese number-to-many-Verbindung an Ihrem Frontend hinzufügen zu können.

Hoffe, das hilft!

Answer 2

Wenn ur apollo Graph Server mit einem zu vielen Beziehungen dann connectors.js, resolvers.js und schema.js Dateien angegebenen Formaten

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]; 

resolvers.js

mit

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; 

connectors.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 };