4장: N+1 문제와 DataLoader 최적화

query {
  posts(first: 10) {
    edges {
      node {
        title
        author {
          name
        }
      }
    }
  }
}

-- 1번째 쿼리: 포스트 10개 조회
SELECT * FROM posts ORDER BY created_at DESC LIMIT 10;
 
-- 2번째 쿼리: 포스트 1의 작성자
SELECT * FROM users WHERE id = 'user-1';
 
-- 3번째 쿼리: 포스트 2의 작성자
SELECT * FROM users WHERE id = 'user-2';
 
-- 4번째 쿼리: 포스트 3의 작성자
SELECT * FROM users WHERE id = 'user-1';  -- 중복!
 
-- ... 총 11번의 쿼리 (1 + 10)

query {
  posts(first: 10) {         # 1 쿼리
    edges {
      node {
        author {              # 10 쿼리
          name
          recentPosts {       # 10 쿼리
            title
            comments(first: 3) { # 100 쿼리
              edges {
                node {
                  author {    # 300 쿼리
                    name
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}
# 최악의 경우: 1 + 10 + 100 + 300 = 411 쿼리

import DataLoader from 'dataloader';
import type { PrismaClient, User } from '@prisma/client';
 
function createUserByIdLoader(prisma: PrismaClient) {
  return new DataLoader<string, User | null>(async (ids) => {
    // 1. 배치된 ID들로 한 번에 조회
    const users = await prisma.user.findMany({
      where: { id: { in: [...ids] } },
    });
 
    // 2. ID 순서에 맞게 매핑 (DataLoader 규약)
    const userMap = new Map(users.map((user) => [user.id, user]));
    return ids.map((id) => userMap.get(id) ?? null);
  });
}

function createPostsByAuthorIdLoader(prisma: PrismaClient) {
  return new DataLoader<string, Post[]>(async (authorIds) => {
    const posts = await prisma.post.findMany({
      where: { authorId: { in: [...authorIds] } },
      orderBy: { createdAt: 'desc' },
    });
 
    // authorId별로 그룹화
    const postsByAuthor = new Map<string, Post[]>();
    for (const post of posts) {
      const existing = postsByAuthor.get(post.authorId) ?? [];
      existing.push(post);
      postsByAuthor.set(post.authorId, existing);
    }
 
    // 입력 키 순서에 맞게 반환 (없으면 빈 배열)
    return authorIds.map((id) => postsByAuthor.get(id) ?? []);
  });
}

function createTagsByPostIdLoader(prisma: PrismaClient) {
  return new DataLoader<string, Tag[]>(async (postIds) => {
    const postTags = await prisma.postTag.findMany({
      where: { postId: { in: [...postIds] } },
      include: { tag: true },
    });
 
    const tagsByPost = new Map<string, Tag[]>();
    for (const pt of postTags) {
      const existing = tagsByPost.get(pt.postId) ?? [];
      existing.push(pt.tag);
      tagsByPost.set(pt.postId, existing);
    }
 
    return postIds.map((id) => tagsByPost.get(id) ?? []);
  });
}

interface Loaders {
  userById: DataLoader<string, User | null>;
  postsByAuthorId: DataLoader<string, Post[]>;
  tagsByPostId: DataLoader<string, Tag[]>;
  commentsByPostId: DataLoader<string, Comment[]>;
}
 
function createLoaders(prisma: PrismaClient): Loaders {
  return {
    userById: createUserByIdLoader(prisma),
    postsByAuthorId: createPostsByAuthorIdLoader(prisma),
    tagsByPostId: createTagsByPostIdLoader(prisma),
    commentsByPostId: createCommentsByPostIdLoader(prisma),
  };
}
 
// 리졸버에서 사용
const resolvers = {
  Post: {
    author: (parent: Post, _args: unknown, context: Context) => {
      return context.loaders.userById.load(parent.authorId);
    },
    tags: (parent: Post, _args: unknown, context: Context) => {
      return context.loaders.tagsByPostId.load(parent.id);
    },
    comments: (parent: Post, _args: unknown, context: Context) => {
      return context.loaders.commentsByPostId.load(parent.id);
    },
  },
};

// 올바른 사용: 매 요청마다 새 컨텍스트에서 생성
async function createContext(): Promise<Context> {
  return {
    loaders: createLoaders(prisma), // 새 인스턴스
  };
}
 
// 잘못된 사용: 전역 공유
// const globalLoaders = createLoaders(prisma); // 절대 금지

interface CommentLoaderKey {
  postId: string;
  first: number;
  orderBy: 'newest' | 'oldest';
}
 
function createCommentsLoader(prisma: PrismaClient) {
  return new DataLoader<CommentLoaderKey, Comment[]>(
    async (keys) => {
      // 동일한 인자를 가진 키들을 그룹화하여 최적화 가능
      const results = await Promise.all(
        keys.map((key) =>
          prisma.comment.findMany({
            where: { postId: key.postId },
            take: key.first,
            orderBy: { createdAt: key.orderBy === 'newest' ? 'desc' : 'asc' },
          })
        )
      );
      return results;
    },
    {
      // 객체 키를 비교하기 위한 캐시 키 함수
      cacheKeyFn: (key) => `${key.postId}:${key.first}:${key.orderBy}`,
    }
  );
}

import depthLimit from 'graphql-depth-limit';
 
const server = new ApolloServer({
  typeDefs,
  resolvers,
  validationRules: [depthLimit(10)], // 최대 깊이 10
});

import { createComplexityRule, simpleEstimator, fieldExtensionsEstimator } from 'graphql-query-complexity';
 
const complexityRule = createComplexityRule({
  maximumComplexity: 1000,
  estimators: [
    fieldExtensionsEstimator(),
    simpleEstimator({ defaultComplexity: 1 }),
  ],
  onComplete: (complexity: number) => {
    console.log(`Query complexity: ${complexity}`);
  },
});
 
// 스키마에서 필드별 비용 지정
const typeDefs = `
  type Query {
    posts(first: Int!): PostConnection! # complexity: first * 10
    user(id: ID!): User                 # complexity: 1
  }
`;

query {
  posts(first: 10) {        # 비용: 10 * 10 = 100
    edges {
      node {
        title              # 비용: 1
        author {           # 비용: 10 (포스트 수)
          name             # 비용: 1
          posts(first: 5) { # 비용: 10 * 5 * 10 = 500
            edges {
              node {
                title      # 비용: 1
              }
            }
          }
        }
      }
    }
  }
}
# 총 비용: 약 613 (임계값 1000 이내)

// Federation 서브그래프의 참조 리졸버
const resolvers = {
  User: {
    __resolveReference: async (
      reference: { __typename: string; id: string },
      context: Context,
    ) => {
      // DataLoader 필수: 라우터가 여러 User 참조를 한 번에 보냄
      return context.loaders.userById.load(reference.id);
    },
  },
};