Question

我正在使用 MongoDB 作为我的数据库和 GraphQL 。我正在为模型使用猫鼬。我意识到我的GraphQL查询速度很慢，因为一次又一次地加载相同的文档。我想用DataLoader解决我的问题，但是我不知道怎么做。

示例

假设我具有以下架构，与朋友一起描述用户：

// mongoose schema
const userSchema = new Schema({
  name: String,
  friendIds: [String],
})

userSchema.methods.friends = function() {
  return User.where("_id").in(this.friendIds)
}

const User = mongoose.model("User", userSchema)

// GraphQL schema
const graphqlSchema = `
  type User {
    id: ID!
    name: String
    friends: [User]
  }

  type Query {
    users: [User]
  }
`

// GraphQL resolver
const resolver = {
  Query: {
    users: () => User.find()
  }
}

这是我数据库中的一些示例数据：

[
  { id: 1, name: "Alice", friendIds: [2, 3] },
  { id: 2, name: "Bob", friendIds: [1, 3] },
  { id: 3, name: "Charlie", friendIds: [2, 4, 5] },
  { id: 4, name: "David", friendIds: [1, 5] },
  { id: 5, name: "Ethan", friendIds: [1, 4, 2] },
]

当我执行以下GraphQL查询时：

{
  users {
    name
    friends {
      name
    }
  }
}

每个用户已加载多次。我希望每个用户Mongoose文档仅加载一次。

什么不起作用

定义用于获取朋友的“全局”数据加载器

如果我将friends方法更改为：

// mongoose schema
const userSchema = new Schema({
  name: String,
  friendIds: [String]
})

userSchema.methods.friends = function() {
  return userLoader.load(this.friendIds)
}

const User = mongoose.model("User", userSchema)

const userLoader = new Dataloader(userIds => {
  const users = await User.where("_id").in(userIds)
  const usersMap = new Map(users.map(user => [user.id, user]))
  return userIds.map(userId => usersMap.get(userId))
})

然后永久缓存我的用户，而不是根据每个请求进行缓存。

在解析器中定义数据加载器

This seems more reasonable : one caching mechanism per request.

// GraphQL resolver
const resolver = {
  Query: {
    users: async () => {
      const userLoader = new Dataloader(userIds => {
        const users = await User.where("_id").in(userIds)
        const usersMap = new Map(users.map(user => [user.id, user]))
        return userIds.map(userId => usersMap.get(userId))
      })
      const userIds = await User.find().distinct("_id")
      return userLoader.load(userIds)
    }
  }
}

但是，在猫鼬模式的userLoader方法中，undefined现在是friends。然后，让我们在解析器中移动模式！

// GraphQL resolver
const resolver = {
  Query: {
    users: async () => {
      const userLoader = new Dataloader(userIds => {
        const users = await User.where("_id").in(userIds)
        const usersMap = new Map(users.map(user => [user.id, user]))
        return userIds.map(userId => usersMap.get(userId))
      })
      const userSchema = new Schema({
        name: String,
        friendIds: [String]
      })
      userSchema.methods.friends = function() {
        return userLoader.load(this.friendIds)
      }
      const User = mongoose.model("User", userSchema)
      const userIds = await User.find().distinct("_id")
      return userLoader.load(userIds)
    }
  }
}

Mh ...现在，Mongoose抱怨第二个请求：解析器再次被调用，Mongoose不喜欢使用相同的模型名称定义两个模型。

“虚拟填充”功能没有用，因为我什至不能告诉Mongoose通过数据加载器而不是直接通过数据库获取模型。

问题

有人遇到过同样的问题吗？有没有人建议如何结合使用Mongoose和Dataloader？谢谢。

注意：我知道因为我的架构是“关系的”，所以我应该使用关系数据库而不是MongoDB。我不是那种选择的人。在我们迁移之前，我必须忍受它。

Answer 1

将猫鼬模式保留在单独的模块中。您不想在每个请求时都创建架构，而只是在第一次导入模块时。

const userSchema = new Schema({
  name: String,
  friendIds: [String]
})
const User = mongoose.model("User", userSchema)

module.exports = { User }

如果需要，还可以导出在同一模块中创建加载程序的函数。但是请注意，我们不想导出加载程序的实例，而只是要导出一个实例的函数。

// ...
const getUserLoader = () => new DataLoader((userIds) => {
  return User.find({ _id: { $in: userIds } }).execute()
})
module.exports = { User, getUserLoader }

接下来，我们要在上下文中包含我们的加载器。具体执行方式将取决于您使用哪个库来实际显示graphql端点。例如，在apollo-server中，上下文作为配置的一部分传入。

new ApolloServer({
    typeDefs,
    resolvers,
    context: ({ req }) => ({
        userLoader: getUserLoader()
    }),
})

这将确保我们为每个请求创建一个新的加载器实例。现在，您的解析器可以像这样调用加载程序：

const resolvers = {
  Query: {
    users: async (root, args, { userLoader }) => {
      // Our loader can't get all users, so let's use the model directly here
      const allUsers = await User.find({})
      // then tell the loader about the users we found
      for (const user of allUsers) {
        userLoader.prime(user.id, user);
      }
      // and finally return the result
      return allUsers
    }
  },
  User: {
    friends: async (user, args, { userLoader }) => {
      return userLoader.loadMany(user.friendIds)
    },
  },
}

如何在GraphQL和DataLoader中使用Mongoose？

示例

什么不起作用

定义用于获取朋友的“全局”数据加载器

在解析器中定义数据加载器

问题

1 个答案: