GraphQL N+1 쿼리 문제 해결: 프로덕션 완벽 가이드

query GetUsersWithPosts {
  users {
    id
    name
    posts {
      title
      content
    }
  }
}

// 단계 1: 모든 사용자 조회 (1개 쿼리)
SELECT * FROM users;
// 100명의 사용자 반환

// 단계 2: 각 사용자마다 게시글 조회 (100개 쿼리!)
SELECT * FROM posts WHERE user_id = 1;
SELECT * FROM posts WHERE user_id = 2;
SELECT * FROM posts WHERE user_id = 3;
// ... 97개 쿼리 더
SELECT * FROM posts WHERE user_id = 100;

// 전통적인 resolver - 문제가 되는 부분
const resolvers = {
  Query: {
    users: async () => {
      return await db.users.findAll()
    }
  },
  User: {
    // 이 resolver가 각 사용자마다 한 번씩 실행됩니다!
    posts: async (user) => {
      return await db.posts.findMany({ userId: user.id })
    }
  }
}

const DataLoader = require('dataloader')

// 배치 로딩 함수 생성
const batchLoadPosts = async (userIds) => {
  console.log('Batching posts for users:', userIds)
  // 모든 사용자를 위한 단일 쿼리!
  const posts = await db.posts.findMany({
    where: {
      userId: { in: userIds }
    }
  })

  // userId별로 게시글 그룹화
  const postsByUserId = {}
  posts.forEach(post => {
    if (!postsByUserId[post.userId]) {
      postsByUserId[post.userId] = []
    }
    postsByUserId[post.userId].push(post)
  })

  // userIds와 동일한 순서로 게시글 반환 (중요!)
  return userIds.map(userId => postsByUserId[userId] || [])
}

// DataLoader 인스턴스 생성
const postsLoader = new DataLoader(batchLoadPosts)

// 업데이트된 resolver
const resolvers = {
  Query: {
    users: async () => {
      return await db.users.findAll()
    }
  },
  User: {
    posts: async (user, args, context) => {
      // DataLoader 사용 - 자동으로 배칭됩니다!
      return context.loaders.postsLoader.load(user.id)
    }
  }
}

const { ApolloServer } = require('@apollo/server')
const DataLoader = require('dataloader')

const server = new ApolloServer({
  typeDefs,
  resolvers,
})

// 요청마다 새로운 loader 생성
app.use('/graphql', async (req, res) => {
  const context = {
    loaders: {
      postsLoader: new DataLoader(batchLoadPosts),
      commentsLoader: new DataLoader(batchLoadComments),
      authorsLoader: new DataLoader(batchLoadAuthors),
    },
    req,
    res,
  }

  // Context와 함께 GraphQL 요청 처리
  await server.executeOperation({ query: req.body.query }, { contextValue: context })
})

const resolvers = {
  Query: {
    users: async () => {
      // JOIN을 사용한 단일 쿼리
      const usersWithPosts = await db.query(`
        SELECT
          u.id as user_id,
          u.name,
          u.email,
          p.id as post_id,
          p.title,
          p.content
        FROM users u
        LEFT JOIN posts p ON u.id = p.user_id
      `)

      // 중첩 구조로 변환
      return transformToNested(usersWithPosts)
    }
  }
}

-- N+1 문제 (100명의 사용자에 대해 101개 쿼리)
SELECT * FROM users;
SELECT * FROM posts WHERE user_id = 1;
SELECT * FROM posts WHERE user_id = 2;
-- ... 98개 쿼리 더

-- DataLoader 사용 (2개 쿼리)
SELECT * FROM users;
SELECT * FROM posts WHERE user_id IN (1, 2, 3, ..., 100);

-- JOIN 사용 (1개 쿼리)
SELECT u.*, p.*
FROM users u
LEFT JOIN posts p ON u.id = p.user_id;

type User {
  id: ID!
  name: String!
  posts: [Post!]!
  # 이것을 추가하세요!
  postsCount: Int!
}

User: {
  postsCount: async (user, args, context) => {
    // 효율적인 COUNT 쿼리, 배칭 가능
    return context.loaders.postsCountLoader.load(user.id)
  }
}

if (queries.length > 50) {
  await sendAlert({
    type: 'N+1_DETECTED',
    operation: requestContext.operationName,
    count: queries.length
  })
}