操作示例

这是 GraphQL Library 7 版本的文档。对于长期支持 (LTS) 版本 5，请参考 GraphQL Library 5 LTS 版本。

本页展示了多个 GraphQL 查询以及如何触发对不同身份验证和授权规则的评估。

每个相关行都有类似 CREATE ON OBJECT Movie 的注释，这意味着将评估如下的身份验证指令。

type Movie @authentication(operations: [CREATE]) @node {
    title: String!
    actors: [Actor!]! @relationship(type: "ACTED_IN", direction: IN)
}

如果指令没有参数，也适用此规则，因为 operations 默认是 all（全部）操作。

以下示例适用于 @authentication 指令，也适用于 @authorization 指令中的任何规则。

查询

对于简单查询，任何被读取的类型都会评估在 operations 中包含 READ 的规则。

query {
    movies {     # READ ON OBJECT Movie
        title    # READ ON FIELD_DEFINITION Movie.title
        actors { # READ ON OBJECT Actor
            name # READ ON FIELD_DEFINITION Actor.name
        }
    }
}

连接

对于连接查询，任何被读取的类型都会评估在 operations 中包含 READ 的规则。

query {
    moviesConnection {
        edges {
            node {                 # READ ON OBJECT Movie
                title              # READ ON FIELD_DEFINITION Movie.title
                actorsConnection {
                    edges {
                        node {     # READ ON OBJECT Actor
                            name   # READ ON FIELD_DEFINITION Actor.name
                        }
                    }
                }
            }
        }
    }
}

聚合

对于聚合查询，任何被聚合的类型都会评估在 operations 中包含 AGGREGATE 的规则。

query {
    moviesConnection {
        aggregate {     # AGGREGATE ON OBJECT Movie
            title {     # AGGREGATE ON FIELD_DEFINITION Movie.title
                longest
            }
        }
    }
}

相同的逻辑也适用于嵌套节点的聚合。

query {
    movies {
        actorsConnection {
            aggregate {         # AGGREGATE ON OBJECT Actor
                node {
                    name {      # AGGREGATE ON FIELD_DEFINITION Actor.name
                        longest
                    }
                }
            }
        }
    }
}

变更

创建

对于 create 变更，会对每个被创建的节点评估对象上的 CREATE 规则，以及字段定义规则。

mutation {
    createMovies(input: [
        {                       # CREATE ON OBJECT Movie
            title: "The Matrix" # CREATE ON FIELD_DEFINITION Movie.title
        }
    ]) {
        movies {                # READ ON OBJECT Movie
            title               # READ ON FIELD_DEFINITION Movie.title
        }
    }
}

删除

对于单个 delete 变更，会评估对象上带有 DELETE 的规则。

mutation {
    deleteMovies(where: { title: { eq: "The Matrix" } }) { # DELETE ON OBJECT Movie
        nodesDeleted
    }
}

对于包含嵌套删除操作的 delete 变更，会评估操作为 DELETE 的规则。

mutation {
    deleteMovies(                                                          # DELETE ON OBJECT Movie
        where: { title: { eq: "The Matrix" } }
        delete: { actors: { where: { node: { name: { eq: "Keanu" } } } } } # DELETE ON OBJECT Actor
    ) {
        nodesDeleted
    }
}

更新

对于具有多种影响的复杂 update 变更，会评估多种规则，并对选择集应用 READ 规则。

mutation {
    updateMovies(
        where: { title: { eq: "The Matrix" } }
        connect: { actors: { where: { node: { name: { eq: "Keanu" } } } } } # CONNECT ON OBJECT Actor and Movie
        update: {                                                           # UPDATE ON OBJECT Movie
            title: { set: "Speed" }                                         # UPDATE ON FIELD_DEFINITION Movie.title
        }
    ) {
        movies {                                                            # READ ON OBJECT Movie
            title                                                           # READ ON FIELD_DEFINITION Movie.title
            actors {                                                        # READ ON OBJECT Actor
                name                                                        # READ ON FIELD_DEFINITION Actor.name
            }
        }
    }
}

订阅

对于简单的创建事件订阅，SUBSCRIBE 和 READ 操作都会触发规则。

subscription {
    movieCreated {     # SUBSCRIBE ON OBJECT Movie
        createdMovie { # READ ON OBJECT Movie
            title      # READ ON FIELD_DEFINITION Movie.title
        }
    }
}

对于更复杂的关系事件订阅，SUBSCRIBE 是一种操作，同时对所有相关类型会触发 READ 操作。

subscription {
    movieRelationshipCreated { # SUBSCRIBE ON OBJECT Movie
        movie {                # READ ON OBJECT Movie
            title              # READ ON FIELD_DEFINITION Movie.title
        }
        createdRelationship {
            actors {
                node {         # READ ON OBJECT Actor
                    name       # READ ON FIELD_DEFINITION Actor.name
                }
            }
        }
    }
}