데이터 로더와 N+1 문제 해결

query {
  posts {
    id
    title
    author { # 이 부분이 N+1 문제를 발생시킵니다.
      id
      username
    }
  }
}

npm install dataloader

nest g s users/loaders/users.loader

// src/users/loaders/users.loader.ts
import { Injectable, Scope } from '@nestjs/common';
import * as DataLoader from 'dataloader'; // DataLoader 임포트
import { UsersService } from '../users.service'; // 사용자 데이터를 가져올 서비스
import { User } from '../models/user.model';

// 요청 스코프로 DataLoader를 생성하여 요청마다 새로운 인스턴스를 보장합니다.
// 이렇게 해야 한 요청 내에서만 배치가 유효하며, 다른 요청과 섞이지 않습니다.
@Injectable({ scope: Scope.REQUEST })
export class UsersLoader {
  constructor(private usersService: UsersService) {}

  // DataLoader 인스턴스를 저장할 속성
  public readonly batchUsers = new DataLoader(async (userIds: number[]) => {
    // 1. 배치 처리: usersService를 통해 여러 ID를 한 번에 조회합니다.
    // 이 메서드는 usersService에 실제 데이터베이스 쿼리 로직을 가집니다.
    // 여기서는 findByIds를 가정합니다.
    console.log(`[DataLoader] Fetching users with IDs: ${userIds.join(', ')}`);
    const users = await this.usersService.findByIds(userIds);

    // 2. 캐싱을 위한 결과 매핑: DataLoader는 요청된 순서대로 결과를 기대합니다.
    // 따라서 Map을 사용하여 ID와 User 객체를 매핑하고, 요청된 ID 순서대로 반환해야 합니다.
    const userMap = new Map<number, User>();
    users.forEach(user => userMap.set(user.id, user));

    return userIds.map(id => userMap.get(id));
  });
}

// src/users/users.service.ts
import { Injectable } from '@nestjs/common';
import { User } from './models/user.model'; // User 모델 임포트 (이전 절에서 정의)

@Injectable()
export class UsersService {
  private users: User[] = [ // 임시 사용자 데이터
    { id: 101, username: 'user1', email: 'user1@example.com' },
    { id: 102, username: 'user2', email: 'user2@example.com' },
    { id: 103, username: 'user3', email: 'user3@example.com' },
    { id: 104, username: 'user4', email: 'user4@example.com' },
  ];

  findOne(id: number): User | undefined {
    return this.users.find(user => user.id === id);
  }

  // DataLoader가 호출할 배치 함수
  async findByIds(ids: number[]): Promise<User[]> {
    // 실제 DB 쿼리: SELECT * FROM users WHERE id IN (101, 102, 103);
    return this.users.filter(user => ids.includes(user.id));
  }
}

// src/users/users.module.ts
import { Module } from '@nestjs/common';
import { UsersService } from './users.service';
import { UsersLoader } from './loaders/users.loader'; // UsersLoader 임포트
// import { UsersV1Controller, UsersV2Controller } from './users.controller'; // REST 컨트롤러 (이 예제와 무관)
import { User } from './models/user.model'; // User 모델도 임포트

@Module({
  // controllers: [UsersV1Controller, UsersV2Controller], // REST 컨트롤러는 여기서 제거하거나 주석 처리
  providers: [UsersService, UsersLoader, User], // UsersLoader와 UsersService를 프로바이더로 등록
  exports: [UsersService, UsersLoader, User], // 다른 모듈에서 사용 가능하도록 export
})
export class UsersModule {}

// src/app.module.ts (업데이트: GraphQLModule 설정)
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { GraphQLModule } from '@nestjs/graphql';
import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
import { join } from 'path';
import { PostsModule } from './posts/posts.module';
import { UsersModule } from './users/users.module'; // UsersModule 임포트
import { UsersLoader } from './users/loaders/users.loader'; // UsersLoader 임포트

@Module({
  imports: [
    GraphQLModule.forRoot<ApolloDriverConfig>({
      driver: ApolloDriver,
      autoSchemaFile: join(process.cwd(), 'src/schema.gql'),
      sortSchema: true,
      playground: true,
      subscriptions: {
        'graphql-ws': true,
        'subscriptions-transport-ws': true,
      },
      // context를 통해 DataLoader 인스턴스 주입
      // 이 함수는 GraphQL 요청마다 실행됩니다.
      context: ({ req, connection }) => {
        // HTTP 요청 (쿼리/뮤테이션) 또는 WebSocket 연결 (서브스크립션)에 따라 다름
        if (connection) {
          // 서브스크립션 연결 시 DataLoader를 초기화
          return { dataLoaders: new UsersLoader(connection.context.usersService) };
        } else {
          // HTTP 요청 시 DataLoader를 초기화 (req.injectedServices에 접근)
          // UsersLoader는 요청 스코프이므로, NestJS의 DI 시스템을 통해 주입받아야 합니다.
          // 이를 위해 ApolloDriverConfig의 buildServiceContext 옵션을 사용하거나,
          // 또는 다음과 같이 Injector를 사용하여 수동으로 인스턴스를 가져올 수 있습니다.
          // NestJS 9+에서는 request.injector를 사용하여 요청 스코프 인스턴스에 접근 가능합니다.
          // 더 간단한 방법은 아래 buildServiceContext를 사용하는 것입니다.
        }
      },
      // NestJS 9+에서 요청 스코프 프로바이더를 GraphQL context에 쉽게 주입하는 방법
      // 이 함수는 각 GraphQL 요청에 대해 한 번만 실행됩니다.
      buildServiceContext: async (context) => {
        const { req, connection } = context;
        if (req) {
          // HTTP 요청 (쿼리, 뮤테이션)
          // UsersLoader 인스턴스를 NestJS의 Request scoped Injector를 통해 가져옵니다.
          const usersLoader = await req.injector.resolve(UsersLoader);
          return { usersLoader };
        } else if (connection) {
          // WebSocket 연결 (서브스크립션)
          // 서브스크립션은 별도의 LifeCycle을 가지므로, DataLoader를 직접 생성합니다.
          // 이 경우 UsersService도 직접 주입해야 할 수 있습니다. (singleton으로 등록된 서비스)
          // 예시: const usersService = app.get(UsersService);
          // return { usersLoader: new UsersLoader(usersService) };
          // 하지만 일반적으로 Subscription Context는 조금 다르게 관리될 수 있습니다.
          // 간단하게는 서브스크립션에서는 DataLoader를 사용하지 않거나,
          // 별도의 DataLoader 인스턴스를 생성하는 것으로 시작할 수 있습니다.
          // 여기서는 간단하게 HTTP 요청에 대해서만 DataLoader를 설정합니다.
          return {}; // 서브스크립션 요청에는 DataLoader가 필요 없을 수도 있습니다.
        }
        return {};
      },
    }),
    PostsModule,
    UsersModule,
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

// src/posts/posts.resolver.ts (업데이트)
import { Resolver, Query, Mutation, Args, Int, ResolveField, Parent, Subscription } from '@nestjs/graphql';
import { Post } from './models/post.model';
import { User } from '../users/models/user.model';
import { CreatePostInput } from './dto/create-post.input';
import { UpdatePostInput } from './dto/update-post.input';
import { PubSub } from 'graphql-subscriptions';
import { UsersLoader } from '../users/loaders/users.loader'; // UsersLoader 임포트
import { GqlContext } from 'src/common/decorators/gql-context.decorator'; // Custom Decorator (아래 정의)

const pubSub = new PubSub();

// GqlContext 커스텀 데코레이터 정의
// src/common/decorators/gql-context.decorator.ts (새로 생성)
import { createParamDecorator, ExecutionContext } from '@nestjs/common';
import { GqlExecutionContext } from '@nestjs/graphql';

export const GqlContext = createParamDecorator(
  (data: unknown, context: ExecutionContext) => {
    const gqlContext = GqlExecutionContext.create(context).getContext();
    return gqlContext;
  },
);


@Resolver(() => Post)
export class PostsResolver {
  private readonly posts: Post[] = [
    { id: 1, title: '첫 번째 게시물', content: 'GraphQL 학습 중입니다.', authorId: 101 }, // authorId로 변경
    { id: 2, title: '두 번째 게시물', content: 'NestJS와 GraphQL 통합!', authorId: 102 }, // authorId로 변경
    { id: 3, title: '세 번째 게시물', content: 'N+1 문제 해결!', authorId: 101 }, // 동일 저자
  ];
  private nextPostId = 4; // nextPostId 업데이트

  // (User 임시 데이터는 UsersService로 이동했으므로 여기서 제거)

  constructor(private readonly usersLoader: UsersLoader) {} // UsersLoader 주입 (컨트롤러 아님 리졸버)

  @Query(() => [Post], { name: 'posts', description: '모든 게시물 목록을 조회합니다.' })
  getAllPosts(): Post[] {
    return this.posts;
  }

  @Query(() => Post, { name: 'post', nullable: true, description: 'ID로 특정 게시물을 조회합니다.' })
  getPost(@Args('id', { type: () => Int, description: '조회할 게시물의 ID' }) id: number): Post | undefined {
    return this.posts.find(post => post.id === id);
  }

  // ResolveField: Post 타입의 author 필드를 해결합니다.
  // DataLoader를 사용하여 N+1 문제를 해결합니다.
  @ResolveField(() => User, { description: '게시물 작성자 정보를 반환합니다.' })
  async author(@Parent() post: Post, @GqlContext() context: any): Promise<User> {
    // context.usersLoader를 통해 DataLoader 인스턴스에 접근
    // console.log(`[ResolveField] Fetching author for post ${post.id} (authorId: ${post.authorId})`);
    return context.usersLoader.batchUsers.load(post.authorId); // DataLoader의 load 메서드 사용
  }

  // Mutation 코드 (createPost, updatePost, deletePost)는 user.model.ts 업데이트를 반영하여 수정 필요
  @Mutation(() => Post, { description: '새로운 게시물을 생성합니다.' })
  async createPost(@Args('createPostInput') createPostInput: CreatePostInput): Promise<Post> {
    const newPost: Post = {
      id: this.nextPostId++,
      title: createPostInput.title,
      content: createPostInput.content,
      authorId: createPostInput.authorId, // authorId 직접 저장
    };
    this.posts.push(newPost);

    await pubSub.publish('postAdded', { postAdded: newPost });
    return newPost;
  }
  // ... (updatePost, deletePost도 authorId 필드를 직접 다루도록 수정)

  // Subscription 코드 (동일)
}

// src/posts/models/post.model.ts
import { Field, Int, ObjectType } from '@nestjs/graphql';
import { User } from '../../users/models/user.model';

@ObjectType()
export class Post {
  @Field(() => Int, { description: '게시물의 고유 ID' })
  id: number;

  @Field({ description: '게시물의 제목' })
  title: string;

  @Field({ nullable: true, description: '게시물의 내용' })
  content?: string;

  @Field(() => Int, { description: '게시물 작성자의 고유 ID (내부용)' })
  authorId: number; // 새로운 필드: 작성자 ID를 직접 가짐

  @Field(() => User, { description: '게시물 작성자 정보' })
  // author 필드는 authorId를 통해 ResolveField에서 해결됩니다.
  author: User; // 이 필드는 실제 데이터가 아니라 GraphQL 스키마를 위한 가상 필드입니다.
}

// src/users/models/user.model.ts
import { Field, Int, ObjectType } from '@nestjs/graphql';

@ObjectType()
export class User {
  @Field(() => Int)
  id: number;

  @Field()
  username: string; // GraphQL 필드로 추가

  @Field()
  email: string; // GraphQL 필드로 추가
}