javascript - 使用 graphql-sequelize 解析器限制递归 GraphQL 架构查询的深度(Node.js、express-graphql)

Question

我有 2 个模型，用户和帖子。我希望能够在查询帖子时获取用户信息，并在查询用户时能够获取用户的所有帖子。

他们有如下关联:

User.hasMany(Post, {
    foreignKey: 'user',
    as: 'posts'
});
Post.belongsTo(User, {
    foreignKey: 'id',
    sourceKey: 'user',
    as: 'userObject'
})

Post.addScope('defaultScope', {
    include: [{ model: User, as: 'userObject' }],
}, { override: true })

User.addScope('defaultScope', {
    include: [{ model: Post, as: 'posts' }],
}, { override: true })

这是我的模型

用户.js

module.exports.userType = new GQL.GraphQLObjectType({
    name: 'User',
    fields: () => {
        const { postType } = require('../Post/Post');
        return {
            id: {
                type: new GQL.GraphQLNonNull(GQL.GraphQLString),
                description: 'user unique id'
            },
            ci_username: {
                type: new GQL.GraphQLNonNull(GQL.GraphQLString),
                unique: true,
                description: 'case INSENSITIVE username of the user'
            },
            username: {
                type: new GQL.GraphQLNonNull(GQL.GraphQLString),
                description: 'case SENSITIVE username of the user'
            },
            password: {
                type: new GQL.GraphQLNonNull(GQL.GraphQLString),
                description: 'password for the user'
            },
            first_name: {
                type: new GQL.GraphQLNonNull(GQL.GraphQLString),
                description: 'first name of user'
            },
            last_name: {
                type: GQL.GraphQLString,
                description: 'last name of user (optional)'
            },
            profile_picture: {
                type: GQL.GraphQLString,
                description: 'profile picture for the user'
            },
            posts: {
                type: GQL.GraphQLList(postType),
                description: 'list of users posts'
            }
        }
    },
})

/** define User model for the database */
module.exports.User = db.define('user', {
    id: {
        type: Sequelize.UUID,
        primaryKey: true, 
        unique: true,
    },
    ci_username: {
        type: Sequelize.STRING,
        unique: true,
    },
    username: Sequelize.STRING,
    password: Sequelize.STRING,
    first_name: Sequelize.STRING,
    last_name: Sequelize.STRING,
    profile_picture: Sequelize.STRING,
}, {
    // Tells sequelize not to query the "CreatedAt" or "UpdatedAt" Columns
    timestamps: false
})

Post.js

module.exports.postType = new GQL.GraphQLObjectType({
    name: 'Post',
    fields: () => {
        const { userType } = require('../User/User');
        return {
            id: {
                type: new GQL.GraphQLNonNull(GQL.GraphQLString),
                description: 'post unique id'
            },
            name: {
                type: new GQL.GraphQLNonNull(GQL.GraphQLString),
                description: 'name of the post'
            },
            user: {
                type: userType,
                description: 'user object of who created the post'
            },
            created_at: {
                type: new GQL.GraphQLNonNull(GQL.GraphQLString),
                description: 'the datetime the post was created',
            }
        }
    },
})

/** define User model for the database */
module.exports.Post = db.define('post', {
    id: {
        type: DataTypes.UUID,
        primaryKey: true, 
        unique: true,
    },
    name: DataTypes.STRING,
    user: {
        type: DataTypes.STRING,
        references: {
            model: 'users',
            key: 'id'
        }
    },
    created_at: {
        type: DataTypes.TIME,
        defaultValue: DataTypes.NOW
    }
}, {
    // Tells sequelize not to query the "CreatedAt" or "UpdatedAt" Columns
    timestamps: false
})

这是我的查询:

allUsers.js

const allUsers = {
    type: new GQL.GraphQLList(userType),
    args: {
        username: {
            description: 'username of the user',
            type: GQL.GraphQLString,
        },
        // An arg with the key limit will automatically be converted to a limit on the target
        limit: {
            type: GQL.GraphQLInt,
            default: 10
        },
        // An arg with the key order will automatically be converted to a order on the target
        order: {
            type: GQL.GraphQLString
        }
    },
    // use graphql-sequelize resolver with the User model from database
    resolve: resolver(User)
}

allPosts.js

const allPosts = {
    type: new GQL.GraphQLList(postType),
    args: {
        username: {
            description: 'username of the user',
            type: GQL.GraphQLString,
        },
        // An arg with the key limit will automatically be converted to a limit on the target
        limit: {
            type: GQL.GraphQLInt,
            default: 10
        },
        // An arg with the key order will automatically be converted to a order on the target
        order: {
            type: GQL.GraphQLString
        }
    },
    // use graphql-sequelize resolver with the Post model from database
    resolve: resolver(Post)
}

我目前收到超过最大调用堆栈大小的消息。我认为是因为查询中的解析器无限递归地获取有关帖子和用户的详细信息。

有人知道有什么方法可以对解析器设置深度限制吗？或者是不可能有这样的递归查询吗？

Answer 1

您必须从包含的模型中删除默认范围，如下所示 here像这样:

Post.addScope('defaultScope', {
    include: [{ model: User.scope(null), as: 'userObject' }],
}, { override: true })

User.addScope('defaultScope', {
    include: [{ model: Post.scope(null), as: 'posts' }],
}, { override: true })

为了支持额外的深度，您需要为相关字段实现解析器，例如:

function resolve (user) {
  if (user.posts) {
    return user.posts
  }
  return user.getPosts()
}