Resolver 设计与 DataLoader

Resolver 函数签名

每个 GraphQL 字段都有一个对应的 Resolver 函数。Resolver 接受四个参数：

// (parent, args, context, info) => value | Promise<value>
type Resolver = (
  parent: T,      // 父字段解析的返回值
  args: Args,     // 字段的参数（如 user(id: "1") 中的 {id: "1"}）
  context: Context, // 跨 Resolver 共享的数据（DB连接、用户信息、DataLoader等）
  info: GraphQLResolveInfo // 查询的元信息（字段名、路径、Schema等）
) => T | Promise<T>;

Resolver 链（Resolver Chain）

const resolvers = {
  // 根查询 Resolver
  Query: {
    users: async (_, __, { db }) => {
      return db.users.findMany();
      // 返回 User 对象数组，parent = 每个 User 对象
    },
  },

  // User 类型的字段 Resolver
  User: {
    // parent 是上面返回的 User 对象
    fullName: (parent) => `${parent.firstName} ${parent.lastName}`,

    // 关联字段：从 parent.id 加载帖子
    posts: async (parent, { limit = 10 }, { db }) => {
      return db.posts.findMany({
        where: { authorId: parent.id },
        take: limit,
      });
    },
  },
};

N+1 问题根因

假设查询 10 个用户的帖子：

query {
  users {      # 查询1次：SELECT * FROM users  (返回10条)
    name
    posts {    # 查询10次：SELECT * FROM posts WHERE authorId = ?
      title
    }
  }
}

这会触发 1 + 10 = 11 次数据库查询——这就是 N+1 问题。当用户数量增大时，数据库查询会线性增长。

DataLoader：批处理解决方案

DataLoader 工作原理

DataLoader 使用批处理（batching）和缓存（caching）两个机制：

• 批处理：在同一个事件循环 tick 内收集所有的 key 请求，然后用一次批量查询获取所有数据
• 缓存：在同一个请求中，相同 key 只查询一次，后续使用缓存结果

import DataLoader from 'dataloader';

// 创建 DataLoader：批处理函数接受 keys 数组，返回对应 values 数组
function createUserLoader(db: PrismaClient) {
  return new DataLoader<string, User>(
    async (userIds: ReadonlyArray) => {
      // 批量查询：1次查询获取所有用户
      const users = await db.users.findMany({
        where: { id: { in: [...userIds] } },
      });

      // 按 key 顺序返回（DataLoader 要求结果顺序与 keys 顺序一致）
      const userMap = new Map(users.map(u => [u.id, u]));
      return userIds.map(id => userMap.get(id) ?? new Error(`User ${id} not found`));
    }
  );
}

在 Context 中注入 DataLoader

// Context 创建（每个请求一个新的 DataLoader 实例）
const server = new ApolloServer({ typeDefs, resolvers });

await startStandaloneServer(server, {
  context: async ({ req }) => ({
    db,
    user: await getUserFromToken(req.headers.authorization),
    // 每个请求创建新的 DataLoader（避免请求间缓存泄漏）
    loaders: {
      user: createUserLoader(db),
      posts: createPostsByAuthorLoader(db),
    },
  }),
});

使用 DataLoader

const resolvers = {
  Post: {
    // 不再直接查数据库，而是使用 DataLoader
    author: (parent, _, { loaders }) => {
      return loaders.user.load(parent.authorId);
      // DataLoader 会在同一 tick 收集所有 authorId，批量查询
    },
  },
};

// 效果：原来 N+1 次查询，现在变成 2 次查询！
// 查询1：SELECT * FROM posts WHERE ...（获取帖子）
// 查询2：SELECT * FROM users WHERE id IN ('u1','u2','u3',...)（批量获取作者）

按关联字段批量加载

// 按作者 ID 批量加载帖子（一对多关系）
function createPostsByAuthorLoader(db: PrismaClient) {
  return new DataLoader<string, Post[]>(
    async (authorIds) => {
      const posts = await db.posts.findMany({
        where: { authorId: { in: [...authorIds] } },
      });

      // 按 authorId 分组
      const grouped = new Map<string, Post[]>();
      for (const post of posts) {
        const arr = grouped.get(post.authorId) ?? [];
        arr.push(post);
        grouped.set(post.authorId, arr);
      }
      return authorIds.map(id => grouped.get(id) ?? []);
    }
  );
}

Resolver 执行机制详解

按需查询优化（info 参数应用）

import { GraphQLResolveInfo } from 'graphql';

// 工具函数：检查客户端是否请求了某个字段
function hasField(info: GraphQLResolveInfo, fieldName: string): boolean {
  return info.fieldNodes[0].selectionSet?.selections.some(
    (s) => s.kind === 'Field' && s.name.value === fieldName
  ) ?? false;
}

const resolvers = {
  Query: {
    user: async (_, { id }, { db }, info) => {
      // 只有当客户端请求了 posts 字段时，才 include posts
      // 避免无谓的 JOIN 查询
      const includePosts = hasField(info, 'posts');

      return db.users.findUnique({
        where: { id },
        include: { posts: includePosts },
      });
    },
  },
};

DataLoader 进阶：缓存失效与强制刷新

// DataLoader 支持手动清除缓存，适合 Mutation 后刷新数据
const resolvers = {
  Mutation: {
    updateUser: async (_, { id, data }, { db, loaders }) => {
      const updated = await db.users.update({ where: { id }, data });

      // 清除该用户的缓存，后续 load 会重新查询
      loaders.user.clear(id);

      // 或者主动填充新数据到缓存，避免额外查询
      loaders.user.prime(id, updated);

      return updated;
    },
  },
};

本章小结