使用基于 GraphQL 游标的分页避免代码重复

Question

我一直在寻找这个问题的答案，我一直在用头撞墙。我写了一个基于光标的分页示例，它适用于 graphql，问题是我认为我会对作者做同样的事情，就像我对书籍所做的那样，我能弄清楚如何做到这一点的唯一方法是完全复制所有内容。在根查询中，有相当长的代码块处理分页，我不想为作者端点做这一切，但我似乎无法在重用代码时找到这样做的方法

这里是代码

const express = require('express')
const { graphqlHTTP } = require('express-graphql')
const {
    GraphQLSchema,
    GraphQLObjectType,
    GraphQLString,
    GraphQLList,
    GraphQLInt,
    GraphQLNonNull
} = require('graphql')

const {
    PageType,
    convertNodeToCursor,
    convertCursorToNodeId
} = require('./pagination')

const app = express()

const authors = [
    { id: 1, name: "Author 1"},
    { id: 2, name: "Author 2"},
    { id: 3, name: "Author 3"}
]

const books = [
    { id: 1, title: "Book 1", authorId: 1 },
    { id: 2, title: "Book 2", authorId: 1 },
    { id: 3, title: "Book 3", authorId: 1 },
    { id: 4, title: "Book 4", authorId: 2 },
    { id: 5, title: "Book 5", authorId: 2 },
    { id: 6, title: "Book 6", authorId: 2 },
    { id: 7, title: "Book 7", authorId: 3 },
    { id: 8, title: "Book 8", authorId: 3 },
    { id: 9, title: "Book 9", authorId: 3 }
]




const Book = new GraphQLObjectType({
    name: 'Book',
    description: 'this is a book',
    fields: () => ({
        id: { type: GraphQLNonNull(GraphQLInt) },
        title: { type: GraphQLNonNull(GraphQLString) },
        authorId: { type: GraphQLNonNull(GraphQLInt) },
        author: {
            type: Author,
            resolve: ({authorId}) => {
                return authors.find(author => author.id === authorId)
            }
        }
    })
})

const Author = new GraphQLObjectType({
    name: 'Author',
    description: 'this represents the author of a book',
    fields: () => ({
        id: { type: GraphQLNonNull(GraphQLInt) },
        name: { type: GraphQLNonNull(GraphQLString) },
        books: { 
            type: GraphQLList(Book),
            resolve: ({id}) => {
                return books.filter(book => book.authorId === id)
            }
        }
    })
})



const RootQuery = new GraphQLObjectType({
    name: 'RootQueryType',
    description: 'this is the root query',
    fields: () => ({
        book: {
            type: Book,
            description: 'a single book',
            args: {
                id: { type: GraphQLInt }
            },
            resolve: (_, { id }) => {
                return books.find(book => book.id === id)
            }
        },
        author: {
            type: Author,
            description: 'a single author',
            args: {
                id: { type: GraphQLInt },
            },
            resolve: (_, { id }) => {
                return authors.find(author => author.id === id)
            }
        },
        books: {
            type: PageType(Book),
            description: 'a list of books',
            args: {
                first: { type: GraphQLInt },
                afterCursor: { type: GraphQLString }
            },
            resolve: (_, { first, afterCursor }) => {
                let afterIndex = 0

                if (typeof afterCursor === 'string') {
                    let nodeId = convertCursorToNodeId(afterCursor)
                    let nodeIndex = books.findIndex(book => book.id === nodeId)
                    if (nodeIndex >= 0) {
                        afterIndex = nodeIndex + 1 
                    }
                }
                    
                const slicedData = books.slice(afterIndex, afterIndex + first)
                console.log('sliced data: ', slicedData)
                const edges = slicedData.map(node => ({
                    node,
                    cursor: convertNodeToCursor(node)
                }))

                let startCursor = null
                let endCursor = null
                if (edges.length > 0) {
                    startCursor = convertNodeToCursor(edges[0].node)
                    endCursor = convertNodeToCursor(edges[edges.length - 1].node)
                }

                let hasNextPage = books.length > afterIndex + first

                return {
                    totalCount: books.length,
                    edges,
                    pageInfo: {
                        startCursor,
                        endCursor,
                        hasNextPage
                    }
                }
            }

        }
    })
})

const schema = new GraphQLSchema({
    query: RootQuery
})

app.use('/graphql', graphqlHTTP({
    schema,
    graphiql: true
}))

app.listen(3000, () => console.log('app running at http://localhost:3000/graphql'))

我在这里处理另一个文件中的分页：

const {
    GraphQLString,
    GraphQLInt,
    GraphQLBoolean,
    GraphQLObjectType,
    GraphQLList,
} = require('graphql')


const Edge = (itemType) => {
    return new GraphQLObjectType({
        name: 'EdgeType',
        fields: () => ({
            node: { type: itemType },
            cursor: { type: GraphQLString }
        })
    })
}

const PageInfo = new GraphQLObjectType({
    name: 'PageInfoType',
    fields: () => ({
        startCursor: { type: GraphQLString },
        endCursor: { type: GraphQLString },
        hasNextPage: { type: GraphQLBoolean }
    })
})

const PageType = (itemType) => {
    return new GraphQLObjectType({
        name: 'PageType',
        fields: () => ({
            totalCount: { type: GraphQLInt },
            edges: { type: new GraphQLList(Edge(itemType)) },
            pageInfo: { type: PageInfo }
        })
    })
}



const convertNodeToCursor = (node) => {
    // Encoding the cursor value to Base 64 as suggested in GraphQL documentation
    return Buffer.from((node.id).toString()).toString('base64')
}

const convertCursorToNodeId = (cursor) => {
    // Decoding the cursor value from Base 64 to integer
    return parseInt(Buffer.from(cursor, 'base64').toString('ascii'))
}

module.exports = {
    PageType,
    convertNodeToCursor,
    convertCursorToNodeId
}

现在，如果我复制并粘贴书籍端点并将其更改为作者，并将类型更改为 PageType(Author)，那么我会收到另一个错误：

Schema must contain uniquely named types but contains multiple types named "PageType".

所以这显然也不是解决方案

Answer 1

您不能拥有一个包含Authors 的EdgeType 和另一个包含Books 的EdgeType。相反，您需要一个 AuthorEdge 和一个 BookEdge 类型。

PageType 也是如此 - 不能有两种不同类型的不同字段但名称相同。

虽然解决方案相对简单 - 如果您在函数中动态生成这些类型，也可以动态命名它们：

const Edge = (itemType) => {
    return new GraphQLObjectType({
        name: itemType.name + 'Edge',
//            ^^^^^^^^^^^^^^^^^^^^^^
        fields: () => ({
            node: { type: itemType },
            cursor: { type: GraphQLString }
        })
    })
}

const PageInfo = new GraphQLObjectType({
    name: 'PageInfo',
    fields: () => ({
        startCursor: { type: GraphQLString },
        endCursor: { type: GraphQLString },
        hasNextPage: { type: GraphQLBoolean }
    })
})

const PageType = (itemType) => {
    return new GraphQLObjectType({
        name: itemType.name + 'sPage',
//            ^^^^^^^^^^^^^^^^^^^^^^^
        fields: () => ({
            totalCount: { type: GraphQLInt },
            edges: { type: new GraphQLList(Edge(itemType)) },
            pageInfo: { type: PageInfo }
        })
    })
}