Question

在GraphQL JS中，假设您具有以下架构。

type User {
    id: Int!
    name: String!
    hasSeen:[Movie!]
}

Type Movie{
    id: Int!
    name: String!
    seenBy: [User!]
}

type Query{
    allUsers:[User]
    allMovies:[Movie]
}

解析器如下（某些部分使用续集）。

const resolvers ={
    User: {
        async hasSeen(user){
            return await user.getMovies();
        }
    },
    Movie: {
        async seenBy(movie){
            return await movie.getUsers();
        }
    },
    Query:{
        async allUsers:{
            return await User.all();
        },
        async allMovies:{
            return await Movie.all();
        }
    }
}

您现在可以通过以下查询来查询用户所观看电影的列表。

query{
    allUsers(){
        id
        name
        hasSeen{
            id
            name
        }
    }
}

这很好，但是您也可以像下面这样永久地循环查询（对长文本表示抱歉）。

query{
    allUsers(){
        id
        name
        hasSeen{
            id
            name
            seenBy{
                id
                name
                hasSeen{
                    id
                    name
                    seenBy{
                        id
                        name
                        hasSeen{
                            id
                            name
                            seenBy{
                                id
                                name
                            }
                        }
                    }
                }
            }
        }
    }
}

我试图寻找答案，但找不到任何东西，但由于我不知道您如何称呼该行为，因此我可能使用了错误的关键字。

您如何看待这种情况？嵌套的边缘？嵌套连接？链状边缘？还有吗？
在这里，我们正在执行用户->电影->用户->电影->等...如何避免这种情况并限制可使用边缘的次数？（例如，一旦以任何方向使用它，便无法再次使用）

我想可以使用解析器完成所有操作，并使用变量控制深度，但是我想知道是否有像Graphql中已经实现的功能？

例如，在我使用的图形数据库中，有一些诸如方向和边线之类的东西，如下所示。

Users 1..1 OUTBOUND

谢谢。

限制graphql模式中的边缘链

0 个答案: