스키마 정의와 리졸버 구현

import { Field, Int, ObjectType } from '@nestjs/graphql';
import { User } from '../../users/models/user.model'; // User 모델 임포트 (아직 생성 안 됨)

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

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

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

  @Field(() => User, { description: '게시물 작성자 정보' }) // User 타입 참조
  author: User; // 사용자 객체를 직접 포함 (Relation)
}

import { Field, Int, ObjectType } from '@nestjs/graphql';
import { Post } from '../../posts/models/post.model'; // Post 모델 임포트 (순환 참조 주의)

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

  @Field()
  username: string;

  @Field()
  email: string;

  // @Field(() => [Post])
  // posts: Post[]; // 만약 User가 작성한 모든 Post를 포함하려면 이렇게 정의할 수 있습니다.
                   // 이 경우 순환 참조 문제(User -> Post -> User)를 해결해야 합니다.
                   // 간단한 예제에서는 일단 생략하거나 TypeORM의 Relation처럼 Lazy Loading 방식으로 처리합니다.
}

import { InputType, Field, Int } from '@nestjs/graphql';
import { IsNotEmpty, IsString, IsInt, Min } from 'class-validator';

@InputType() // 이 클래스가 GraphQL Input Type임을 선언
export class CreatePostInput {
  @ApiProperty({ description: '새 게시물의 제목' }) // Swagger 통합을 위한 데코레이터 (선택 사항)
  @IsNotEmpty({ message: '제목은 필수 항목입니다.' })
  @IsString({ message: '제목은 문자열이어야 합니다.' })
  @Field({ description: '게시물의 제목' })
  title: string;

  @ApiProperty({ description: '새 게시물의 내용', required: false })
  @IsString({ message: '내용은 문자열이어야 합니다.' })
  @Field({ nullable: true, description: '게시물의 내용' })
  content?: string;

  @ApiProperty({ description: '게시물 작성자 ID' })
  @IsInt({ message: '작성자 ID는 정수여야 합니다.' })
  @Min(1, { message: '작성자 ID는 1 이상이어야 합니다.' })
  @Field(() => Int, { description: '게시물 작성자의 고유 ID' })
  authorId: number;
}

import { InputType, Field, Int, PartialType } from '@nestjs/graphql';
import { CreatePostInput } from './create-post.input';
import { IsInt, Min, IsOptional } from 'class-validator';

@InputType()
export class UpdatePostInput extends PartialType(CreatePostInput) {
  @ApiProperty({ description: '업데이트할 게시물의 ID' })
  @IsInt({ message: 'ID는 정수여야 합니다.' })
  @Min(1, { message: 'ID는 1 이상이어야 합니다.' })
  @Field(() => Int, { description: '업데이트할 게시물의 고유 ID' })
  id: number;

  @ApiProperty({ description: '게시물 작성자 ID (선택 사항)' })
  @IsOptional()
  @IsInt({ message: '작성자 ID는 정수여야 합니다.' })
  @Min(1, { message: '작성자 ID는 1 이상이어야 합니다.' })
  @Field(() => Int, { nullable: true, description: '게시물 작성자의 고유 ID (업데이트 시 선택 사항)' })
  authorId?: number;
}

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'; // User 모델 임포트
import { CreatePostInput } from './dto/create-post.input';
import { UpdatePostInput } from './dto/update-post.input';
import { PubSub } from 'graphql-subscriptions'; // PubSub 임포트 (서브스크립션용)

const pubSub = new PubSub(); // PubSub 인스턴스 생성 (실제 앱에서는 Singleton으로 관리)

@Resolver(() => Post)
export class PostsResolver {
  // 임시 데이터 스토어 (실제는 DB 연동)
  private readonly posts: Post[] = [
    { id: 1, title: '첫 번째 게시물', content: 'GraphQL 학습 중입니다.', author: { id: 101, username: 'user1', email: 'user1@example.com' } },
    { id: 2, title: '두 번째 게시물', content: 'NestJS와 GraphQL 통합!', author: { id: 102, username: 'user2', email: 'user2@example.com' } },
  ];
  private nextPostId = 3;

  private readonly 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' },
  ];

  @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 필드를 해결합니다.
  // Post 쿼리에서 author 필드가 요청될 때 이 메서드가 실행됩니다.
  @ResolveField(() => User, { description: '게시물 작성자 정보를 반환합니다.' })
  author(@Parent() post: Post): User {
    // 실제로는 post.authorId를 사용하여 데이터베이스에서 사용자 정보를 조회합니다.
    return this.users.find(user => user.id === post.author.id); // 현재는 임시 데이터에서 조회
  }
}

// ... (기존 import 및 Query 코드)

@Resolver(() => Post)
export class PostsResolver {
  // ... (posts, nextPostId, users 데이터 및 Query 코드)

  @Mutation(() => Post, { description: '새로운 게시물을 생성합니다.' })
  async createPost(@Args('createPostInput') createPostInput: CreatePostInput): Promise<Post> {
    const author = this.users.find(u => u.id === createPostInput.authorId);
    if (!author) {
      throw new Error(`Author with ID ${createPostInput.authorId} not found`);
    }

    const newPost: Post = {
      id: this.nextPostId++,
      ...createPostInput,
      author: author,
    };
    this.posts.push(newPost);

    // 새로운 게시물이 생성되었음을 서브스크립션 리스너에게 알림
    await pubSub.publish('postAdded', { postAdded: newPost }); // 'postAdded' 이벤트 발행

    return newPost;
  }

  @Mutation(() => Post, { description: '기존 게시물을 업데이트합니다.', nullable: true })
  async updatePost(@Args('updatePostInput') updatePostInput: UpdatePostInput): Promise<Post | undefined> {
    const postIndex = this.posts.findIndex(p => p.id === updatePostInput.id);
    if (postIndex === -1) {
      return undefined; // 게시물 없음
    }

    let author: User | undefined = this.posts[postIndex].author;
    if (updatePostInput.authorId) {
      author = this.users.find(u => u.id === updatePostInput.authorId);
      if (!author) {
        throw new Error(`Author with ID ${updatePostInput.authorId} not found`);
      }
    }

    this.posts[postIndex] = {
      ...this.posts[postIndex],
      ...updatePostInput,
      author: author, // 업데이트된 author
    };
    const updatedPost = this.posts[postIndex];

    await pubSub.publish('postUpdated', { postUpdated: updatedPost }); // 'postUpdated' 이벤트 발행

    return updatedPost;
  }

  @Mutation(() => Boolean, { description: 'ID로 게시물을 삭제합니다.' })
  async deletePost(@Args('id', { type: () => Int, description: '삭제할 게시물의 ID' }) id: number): Promise<boolean> {
    const initialLength = this.posts.length;
    const deletedPost = this.posts.find(p => p.id === id); // 삭제될 게시물 찾기
    this.posts = this.posts.filter(post => post.id !== id);

    if (this.posts.length < initialLength) {
      if (deletedPost) {
        await pubSub.publish('postDeleted', { postDeleted: id }); // 'postDeleted' 이벤트 발행
      }
      return true; // 삭제 성공
    }
    return false; // 삭제 실패 (게시물 없음)
  }

  // ... (ResolveField 코드)
}

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 임포트 (아직 생성 안 했으면 생성)

@Module({
  imports: [
    GraphQLModule.forRoot<ApolloDriverConfig>({
      driver: ApolloDriver,
      autoSchemaFile: join(process.cwd(), 'src/schema.gql'),
      sortSchema: true,
      playground: true,
      // 구독(Subscription) 설정 추가
      subscriptions: {
        'graphql-ws': true, // WebSockets를 통한 구독 활성화
        'subscriptions-transport-ws': true, // 레거시 클라이언트를 위한 지원 (선택 사항)
      },
    }),
    PostsModule,
    UsersModule, // UsersModule 임포트 (user.model.ts를 사용하기 위함)
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

// ... (기존 import, Query, Mutation 코드)

@Resolver(() => Post)
export class PostsResolver {
  // ... (posts, nextPostId, users 데이터 및 Query, Mutation 코드)

  @Subscription(() => Post, { description: '새로운 게시물이 생성될 때 알림을 받습니다.' })
  postAdded() {
    // PubSub의 'postAdded' 이벤트 리스너를 반환
    return pubSub.asyncIterator('postAdded');
  }

  @Subscription(() => Post, { description: '게시물이 업데이트될 때 알림을 받습니다.' })
  postUpdated() {
    return pubSub.asyncIterator('postUpdated');
  }

  @Subscription(() => Int, { description: '게시물이 삭제될 때 해당 ID를 알림받습니다.' })
  postDeleted() {
    return pubSub.asyncIterator('postDeleted');
  }
}