3장: Resolver 구현과 데이터 로딩

type ResolverFn<TParent, TArgs, TContext, TResult> = (
  parent: TParent,    // 부모 리졸버의 반환값
  args: TArgs,        // 클라이언트가 전달한 인자
  context: TContext,   // 요청 전체에 공유되는 객체
  info: GraphQLResolveInfo, // 쿼리 실행 정보 (AST, 필드 이름 등)
) => TResult | Promise<TResult>;

query {
  post(id: "1") {
    title
    author {
      name
      avatar
    }
    comments(first: 5) {
      edges {
        node {
          body
          author {
            name
          }
        }
      }
    }
  }
}

// GraphQL 런타임의 기본 리졸버 동작
function defaultFieldResolver(parent: Record<string, unknown>, _args: unknown, _context: unknown, info: GraphQLResolveInfo) {
  return parent[info.fieldName];
}

const resolvers = {
  Query: {
    post: async (_parent: unknown, args: { id: string }, context: Context) => {
      return context.dataSources.posts.findById(args.id);
    },
  },
  Post: {
    author: async (parent: Post, _args: unknown, context: Context) => {
      // parent에는 Query.post 리졸버가 반환한 Post 객체가 들어옴
      return context.dataSources.users.findById(parent.authorId);
    },
    comments: async (parent: Post, args: PaginationArgs, context: Context) => {
      return context.dataSources.comments.findByPostId(parent.id, args);
    },
  },
  Comment: {
    author: async (parent: Comment, _args: unknown, context: Context) => {
      return context.dataSources.users.findById(parent.authorId);
    },
  },
};

import type { PrismaClient } from '@prisma/client';
import type DataLoader from 'dataloader';
 
interface AuthenticatedUser {
  id: string;
  role: 'ADMIN' | 'USER' | 'EDITOR';
  permissions: string[];
}
 
interface DataSources {
  users: UserDataSource;
  posts: PostDataSource;
  comments: CommentDataSource;
}
 
interface Loaders {
  userById: DataLoader<string, User>;
  postsByAuthorId: DataLoader<string, Post[]>;
}
 
interface Context {
  currentUser: AuthenticatedUser | null;
  dataSources: DataSources;
  loaders: Loaders;
  prisma: PrismaClient;
  requestId: string;
}

import { v4 as uuid } from 'uuid';
 
async function createContext({ req }: { req: Request }): Promise<Context> {
  const token = req.headers.get('authorization')?.replace('Bearer ', '');
  const currentUser = token ? await verifyToken(token) : null;
 
  const requestId = uuid();
 
  return {
    currentUser,
    dataSources: {
      users: new UserDataSource(prisma),
      posts: new PostDataSource(prisma),
      comments: new CommentDataSource(prisma),
    },
    loaders: createLoaders(prisma),
    prisma,
    requestId,
  };
}

abstract class BaseDataSource<T> {
  constructor(protected prisma: PrismaClient) {}
 
  abstract findById(id: string): Promise<T | null>;
  abstract findAll(args: PaginationArgs): Promise<T[]>;
  abstract count(filter?: Record<string, unknown>): Promise<number>;
}
 
class PostDataSource extends BaseDataSource<Post> {
  async findById(id: string): Promise<Post | null> {
    return this.prisma.post.findUnique({ where: { id } });
  }
 
  async findAll(args: PaginationArgs): Promise<Post[]> {
    return this.prisma.post.findMany({
      take: args.first ?? 20,
      cursor: args.after ? { id: args.after } : undefined,
      skip: args.after ? 1 : 0,
      orderBy: { createdAt: 'desc' },
    });
  }
 
  async count(): Promise<number> {
    return this.prisma.post.count();
  }
 
  async findByAuthorId(authorId: string): Promise<Post[]> {
    return this.prisma.post.findMany({
      where: { authorId },
      orderBy: { createdAt: 'desc' },
    });
  }
 
  async create(input: CreatePostInput, authorId: string): Promise<Post> {
    return this.prisma.post.create({
      data: { ...input, authorId },
    });
  }
}

const resolvers = {
  Post: {
    // 계산된 필드: DB에 없지만 리졸버에서 생성
    readingTime: (parent: Post) => {
      const wordsPerMinute = 200;
      const wordCount = parent.content.split(/\s+/).length;
      return Math.ceil(wordCount / wordsPerMinute);
    },
    // 포맷된 필드
    formattedDate: (parent: Post) => {
      return new Intl.DateTimeFormat('ko-KR', {
        year: 'numeric',
        month: 'long',
        day: 'numeric',
      }).format(new Date(parent.createdAt));
    },
  },
};

const resolvers = {
  // 유니온 타입 리졸버
  SearchResult: {
    __resolveType(obj: { __typename?: string; title?: string; body?: string }) {
      if (obj.__typename) return obj.__typename;
      if ('title' in obj) return 'Post';
      if ('body' in obj) return 'Comment';
      return 'User';
    },
  },
  // 인터페이스 타입 리졸버
  Node: {
    __resolveType(obj: { __typename: string }) {
      return obj.__typename;
    },
  },
};

import { ApolloServer } from '@apollo/server';
import { startStandaloneServer } from '@apollo/server/standalone';
import { readFileSync } from 'fs';
 
const typeDefs = readFileSync('./schema.graphql', 'utf8');
 
const server = new ApolloServer({
  typeDefs,
  resolvers,
  plugins: [
    ApolloServerPluginDrainHttpServer({ httpServer }),
    {
      async requestDidStart() {
        return {
          async didResolveOperation(requestContext) {
            console.log(`Operation: ${requestContext.operationName}`);
          },
          async didEncounterErrors(requestContext) {
            for (const error of requestContext.errors) {
              console.error('GraphQL Error:', error);
            }
          },
        };
      },
    },
  ],
});
 
const { url } = await startStandaloneServer(server, {
  listen: { port: 4000 },
  context: createContext,
});
 
console.log(`Server ready at ${url}`);

import { createSchema, createYoga } from 'graphql-yoga';
import { createServer } from 'node:http';
 
const yoga = createYoga({
  schema: createSchema({
    typeDefs: /* GraphQL */ `
      type Query {
        post(id: ID!): Post
      }
      type Post {
        id: ID!
        title: String!
        author: User!
      }
      type User {
        id: ID!
        name: String!
      }
    `,
    resolvers,
  }),
  context: createContext,
  maskedErrors: process.env.NODE_ENV === 'production',
  logging: true,
});
 
const server = createServer(yoga);
server.listen(4000, () => {
  console.log('Yoga server is running on http://localhost:4000/graphql');
});

import { GraphQLError } from 'graphql';
 
const resolvers = {
  Query: {
    post: async (_parent: unknown, args: { id: string }, context: Context) => {
      const post = await context.dataSources.posts.findById(args.id);
      
      if (!post) {
        throw new GraphQLError('Post not found', {
          extensions: {
            code: 'NOT_FOUND',
            argumentName: 'id',
          },
        });
      }
 
      if (post.status === 'DRAFT' && context.currentUser?.id !== post.authorId) {
        throw new GraphQLError('Not authorized to view this draft', {
          extensions: { code: 'FORBIDDEN' },
        });
      }
 
      return post;
    },
  },
};

type Mutation {
  createPost(input: CreatePostInput!): CreatePostResult!
}
 
union CreatePostResult = CreatePostSuccess | ValidationError | AuthenticationError
 
type CreatePostSuccess {
  post: Post!
}
 
type ValidationError {
  field: String!
  message: String!
}
 
type AuthenticationError {
  message: String!
}