Ariadne-Relay

Ariadne-Relay提供了一套在Python中实现符合GraphQL服务器规范的工具集，使用Ariadne库。

Ariadne-Relay的目标是

• 使构建Relay功能的感觉尽可能接近核心Ariadne
• 最小化常见情况的样板代码
• 尽可能使全面自定义和优化Relay部署变得简单

安装

Ariadne-Relay可以使用pip安装

pip install ariadne-relay

快速入门

如果您对Ariadne的一般使用不熟悉，请从Araidne文档开始。

以下是一个Ariadne快速入门的变体，作为Relay实现

from dataclasses import dataclass

from ariadne import gql, InterfaceType, make_executable_schema
from ariadne.asgi import GraphQL

from ariadne_relay import NodeObjectType, RelayQueryType, resolve_node_query


# Using a dataclass for Person rather than a dict,
# since it works better with a Node implementation
@dataclass
class Person:
    id: int
    firstName: str
    lastName: str
    age: int


type_defs = gql(
    """
    type Query {
        node(id: ID!): Node
        people(
            after: String
            before: String
            first: Int
            last: Int
        ): PeopleConnection!
    }

    interface Node {
        id: ID!
    }

    type PageInfo {
        hasNextPage: Boolean!
        hasPreviousPage: Boolean!
        startCursor: String
        endCursor: String
    }

    type Person implements Node {
        id: ID!
        firstName: String
        lastName: String
        age: Int
        fullName: String
    }

    type PersonEdge {
        cursor: String!
        node: Person
    }

    type PeopleConnection {
        pageInfo: PageInfo!
        edges: [PersonEdge]!
    }
"""
)

# A mock data store of people
people_data = {
    "1": Person(id=1, firstName="John", lastName="Doe", age=21),
    "2": Person(id=2, firstName="Bob", lastName="Boberson", age=24),
}

# Instead of using Ariadne's QueryType, use the Relay-enabled
# RelayQueryType class
query = RelayQueryType()

# resolve_node_query is provided as a resolver for Query.node()
query.set_field("node", resolve_node_query)

# Connection resolvers work exactly like standard Ariadne resolvers,
# except they convert the returned value to a connection structure
@query.connection("people")
def resolve_people(*_):
    return list(people_data.values())


# Define the Node interface
node = InterfaceType("Node")

# Add a Node type resolver
@node.type_resolver
def resolve_node_type(obj, *_):
    return obj.__class__.__name__


# Instead of Ariadne's ObjectType, use the Relay-enabled
# NodeObjectType class for types that implement Node
person = NodeObjectType("Person")


# Add an instance_resolver to define how an instance of
# this type is retrieved, given an id
@person.instance_resolver
def resolve_person_instance(id, *_):
    return people_data.get(id)


@person.field("fullName")
def resolve_person_fullname(person, *_):
    return "%s %s" % (person.firstName, person.lastName)


# Create executable GraphQL schema
schema = make_executable_schema(type_defs, node, query, person)

# Create an ASGI app using the schema, running in debug mode
app = GraphQL(schema, debug=True)

连接工厂

在RelayObjectType.connection()中生成连接结构的繁重工作由选择的工厂执行。您可以通过在调用connection()时传递它来指定您选择的工厂。

@query.connection("people", factory=CustomConnection)

ReferenceConnection

当未覆盖 factory 时，默认使用 ReferenceConnection。此实现包装了 graphql_relay.connection_from_array_slice() 并提供了 Relay 参考实现预期的行为。

SnakeCaseConnection

SnakeCaseConnection 工厂提供了与 ReferenceConnection 相似的功能，但返回具有蛇形字段名称的连接结构。这对于与 ariadne.snake_case_fallback_resolvers 结合使用很有用。

ConnectionProxy

ConnectionProxy 工厂可用于代理已形成的连接结构，例如由外部 GraphQL 端点生成的有效负载。它只是无修改地传递数据。

自定义工厂

许多部署将从自定义连接工厂中受益。一个例子是将特定的 ORM（如 Djano）正确集成。其他例子可能包括扩展连接功能或自定义游标的形成方式。在此目的上，BaseConnection 和 SnakeCaseBaseConnection 类可能很有用。

贡献

请参阅 CONTRIBUTING.md。