02 — 리졸버 함수 (Resolver Function)

// REST
app.get('/users/:id/posts', async (req, res) => {
  const user = await db.users.find(req.params.id);
  const posts = await db.posts.where({ authorId: user.id });
  res.json({ ...user, posts });
});

// GraphQL — 필드마다 별도 함수
const resolvers = {
  Query: {
    user: (_, { id }, ctx) => ctx.db.users.find(id),
  },
  User: {
    posts: (user, _, ctx) => ctx.db.posts.where({ authorId: user.id }),
  },
};

type Resolver<Parent, Args, Context, Result> = (
  parent:  Parent,    // 1. 위치 — 부모 객체
  args:    Args,      // 2. 요청 — 이 필드의 인자 (coerced)
  context: Context,   // 3. 요청-스코프 — 인증·DataLoader·db 핸들
  info:    GraphQLResolveInfo,  // 4. 메타 — 현재 노드의 자기 인식
) => Result | Promise<Result>;

query {
  user(id: "1") {     # Query.user 리졸버 → returns { id: "1", name: "Ada" }
    name              # User.name 리졸버의 parent = { id: "1", name: "Ada" }
    posts {           # User.posts 리졸버의 parent = { id: "1", name: "Ada" }
      title           # Post.title 리졸버의 parent = { id, title, authorId }
    }
  }
}

type Query {
  user(id: ID!, includeDeleted: Boolean = false): User
}

Query: {
  user: (_, args, ctx) => {
    // args = { id: "1", includeDeleted: false }
    // 1. variables 치환 끝남
    // 2. default value 적용 끝남
    // 3. scalar coerce 끝남 (ID → string, Int → number)
    // 4. Input Object 검증 끝남
    return ctx.db.users.find(args.id);
  }
}

interface GraphQLResolveInfo {
  fieldName:    string;            // "posts"
  fieldNodes:   FieldNode[];       // 같은 이름의 AST 노드들 (fragment merge 결과)
  returnType:   GraphQLOutputType; // [Post!]!
  parentType:   GraphQLObjectType; // User
  path:         { key, prev };     // user → posts (응답에서의 위치)
  schema:       GraphQLSchema;
  fragments:    { [name]: FragmentDefinitionNode };
  rootValue:    any;
  operation:    OperationDefinitionNode;
  variableValues: { ... };
}

const defaultFieldResolver = (parent, args, ctx, info) => {
  if (parent == null) return null;
  const value = parent[info.fieldName];
  return typeof value === 'function' ? value.call(parent, args, ctx, info) : value;
};

// User.id, User.name 리졸버는 명시하지 않아도 동작 — db row가 이미 그 모양
Query: {
  user: (_, { id }, ctx) => ctx.db.users.find(id),  // { id, name, email } 반환
},
// User: { id, name, email은 default resolver가 처리 }

const DateScalar = new GraphQLScalarType({
  name: 'Date',
  serialize:    (value) => value.toISOString(),   // resolver 반환 → JSON
  parseValue:   (value) => new Date(value),       // variables → resolver args
  parseLiteral: (ast) => new Date(ast.value),     // 인라인 리터럴 → args
});

User: {
  posts:    async (user, _, ctx) => ctx.db.posts.byAuthor(user.id),   // 50ms
  comments: async (user, _, ctx) => ctx.db.comments.byAuthor(user.id), // 80ms
}
// → 합쳐서 80ms (parallel), 130ms 아님

type User { fullName: String }

// row: { full_name: "Ada Lovelace" }
// fullName 리졸버 없으면 → null
User: {
  fullName: (user) => user.full_name,   // 명시 필요
}

// 안티패턴
User: {
  posts: (user, _, ctx) => ctx.db.posts.byAuthor(ctx.currentUserId),  // ❌ ctx.currentUserId?
}

type Mutation {
  transfer(from: ID!, to: ID!, amount: Int!): Receipt
}

const result = resolveFn(source, args, contextValue, info);

User: {
  posts: (user, args, ctx) => ctx.services.posts.byAuthor(user.id, args),  // ✅ thin
  // 비즈니스 로직은 ctx.services.posts 안에
}