使用 graphql-sequelize 解析器（Node.js、express-graphql）限制遞歸 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
})

這是我的查詢：

所有用戶.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)
}

所有帖子.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)
}

我目前收到Maximum call stack size exceeded 。 我假設是因為查詢中的resolver無限遞歸地獲取有關帖子和用戶的詳細信息。

有誰知道有什么方法可以對解析器設置深度限制？ 還是不可能有這樣的遞歸查詢？

Answer 1

你將不得不從如圖所示，包括模型刪除默認的范圍在這里是這樣的：

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()
}