type User {
  id: ID!              # ! 는 필수 필드를 의미
  name: String!
  email: String
  age: Int
  posts: [Post!]!      # Post 배열
  createdAt: DateTime!
}

type Post {
  id: ID!
  title: String!
  content: String!
  author: User!        # User 타입 참조
  comments: [Comment!]!
  publishedAt: DateTime
}

type Comment {
  id: ID!
  content: String!
  author: User!
  post: Post!
}

type Query {
  user(id: ID!): User
  users(limit: Int, offset: Int): [User!]!
  post(id: ID!): Post
  posts(authorId: ID): [Post!]!
}

type Mutation {
  createUser(name: String!, email: String!): User!
  updateUser(id: ID!, name: String, email: String): User!
  deleteUser(id: ID!): Boolean!
  createPost(title: String!, content: String!, authorId: ID!): Post!
}

# 기본 쿼리 - 사용자 이름만 가져오기
query {
  user(id: "1") {
    name
  }
}

# 중첩 쿼리 - 사용자와 그의 게시글까지
query {
  user(id: "1") {
    name
    email
    posts {
      title
      publishedAt
    }
  }
}

# 별칭 사용 - 같은 필드를 다른 인자로 여러 번 조회
query {
  user1: user(id: "1") {
    name
  }
  user2: user(id: "2") {
    name
  }
}

# 변수 사용 - 동적 쿼리
query GetUser($userId: ID!) {
  user(id: $userId) {
    name
    email
    posts(limit: 5) {
      title
    }
  }
}

# 프래그먼트 - 재사용 가능한 쿼리 조각
fragment UserInfo on User {
  name
  email
  createdAt
}

query {
  user(id: "1") {
    ...UserInfo
    posts {
      title
    }
  }
}

// Node.js + Apollo Server 예제
const resolvers = {
  Query: {
    user: async (parent, { id }, context) => {
      // 데이터베이스에서 사용자 조회
      return await context.db.users.findById(id);
    },
    
    users: async (parent, { limit, offset }, context) => {
      return await context.db.users.find()
        .limit(limit)
        .skip(offset);
    }
  },
  
  User: {
    // User의 posts 필드를 위한 리졸버
    posts: async (parent, args, context) => {
      // parent는 User 객체
      return await context.db.posts.find({ 
        authorId: parent.id 
      });
    }
  },
  
  Mutation: {
    createUser: async (parent, { name, email }, context) => {
      const newUser = await context.db.users.create({
        name,
        email,
        createdAt: new Date()
      });
      return newUser;
    },
    
    updateUser: async (parent, { id, name, email }, context) => {
      const updatedUser = await context.db.users.update(id, {
        name,
        email
      });
      return updatedUser;
    }
  }
};

// ❌ 나쁜 예
GET /getUsers
POST /createUser
DELETE /deleteUser/123

// ✅ 좋은 예
GET /users
POST /users
DELETE /users/123

// 사용자의 게시글
GET /users/123/posts

// 게시글의 댓글
GET /posts/456/comments

// 특정 댓글
GET /posts/456/comments/789

// ✅ 일관성 있는 복수형
GET /users
GET /users/123
GET /posts
GET /posts/456

// ✅ 읽기 쉬운 URL
GET /user-profiles
GET /blog-posts
GET /payment-methods

// 쿼리 파라미터 활용
GET /users?role=admin&status=active
GET /posts?sort=createdAt&order=desc
GET /products?page=2&limit=20
GET /articles?category=tech&author=123

// Express.js 예제
app.post('/users', async (req, res) => {
  try {
    // 유효성 검증
    const errors = validateUser(req.body);
    if (errors.length > 0) {
      return res.status(422).json({ errors });
    }
    
    // 중복 확인
    const existing = await User.findByEmail(req.body.email);
    if (existing) {
      return res.status(409).json({ 
        error: 'Email already exists' 
      });
    }
    
    // 생성
    const user = await User.create(req.body);
    res.status(201).json(user);
    
  } catch (error) {
    console.error(error);
    res.status(500).json({ 
      error: 'Internal server error' 
    });
  }
});

// JWT 기반 인증 미들웨어
const jwt = require('jsonwebtoken');

const authenticate = (req, res, next) => {
  const token = req.headers.authorization?.split(' ')[1];
  
  if (!token) {
    return res.status(401).json({ 
      error: 'Authentication required' 
    });
  }
  
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch (error) {
    res.status(401).json({ 
      error: 'Invalid token' 
    });
  }
};

// 권한 확인 미들웨어
const authorize = (roles) => {
  return (req, res, next) => {
    if (!roles.includes(req.user.role)) {
      return res.status(403).json({ 
        error: 'Insufficient permissions' 
      });
    }
    next();
  };
};

// 사용 예
app.get('/admin/users', 
  authenticate, 
  authorize(['admin']), 
  async (req, res) => {
    const users = await User.findAll();
    res.json(users);
  }
);

// Rate Limiting
const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15분
  max: 100, // 최대 100 요청
  message: 'Too many requests'
});

app.use('/api/', limiter);

// ❌ 데이터베이스 중심
type User {
  user_id: Int!
  user_name: String!
  created_at: String!
  updated_at: String!
}

// ✅ 비즈니스 도메인 중심
type User {
  id: ID!
  name: String!
  displayName: String!
  profile: UserProfile!
  createdAt: DateTime!
}

type UserProfile {
  bio: String
  avatar: String
  socialLinks: [SocialLink!]!
}

type User {
  id: ID!              # 항상 존재 (!)
  name: String!        # 항상 존재
  email: String        # 선택적 (nullable)
  phone: String        # 선택적
  posts: [Post!]!      # 배열은 항상 존재, 요소도 항상 존재
  friends: [User!]     # 배열은 null 가능, 요소는 항상 존재
}

// Relay 스타일 커서 기반 페이지네이션
type Query {
  posts(
    first: Int
    after: String
    last: Int
    before: String
  ): PostConnection!
}

type PostConnection {
  edges: [PostEdge!]!
  pageInfo: PageInfo!
  totalCount: Int!
}

type PostEdge {
  node: Post!
  cursor: String!
}

type PageInfo {
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
  endCursor: String
}

// 오프셋 기반 페이지네이션 (간단한 경우)
type Query {
  posts(limit: Int, offset: Int): PostList!
}

type PostList {
  items: [Post!]!
  total: Int!
  hasMore: Boolean!
}

// DataLoader 설정
const DataLoader = require('dataloader');

// 배치 로딩 함수
const batchUsers = async (userIds) => {
  const users = await User.findAll({
    where: { id: userIds }
  });
  
  // ID 순서대로 정렬
  const userMap = {};
  users.forEach(user => {
    userMap[user.id] = user;
  });
  
  return userIds.map(id => userMap[id]);
};

// Context에 DataLoader 추가
const createContext = () => ({
  loaders: {
    user: new DataLoader(batchUsers)
  }
});

// 리졸버에서 사용
const resolvers = {
  Post: {
    author: async (post, args, context) => {
      // N+1 문제 없이 배치로 로딩
      return context.loaders.user.load(post.authorId);
    }
  }
};

// 사용 예
const server = new ApolloServer({
  typeDefs,
  resolvers,
  context: createContext
});

// 1. 쿼리 복잡도 제한
const { createComplexityLimitRule } = require('graphql-validation-complexity');

const server = new ApolloServer({
  typeDefs,
  resolvers,
  validationRules: [
    createComplexityLimitRule(1000, {
      onCost: (cost) => {
        console.log('Query cost:', cost);
      }
    })
  ]
});

// 2. 깊이 제한
const depthLimit = require('graphql-depth-limit');

const server = new ApolloServer({
  typeDefs,
  resolvers,
  validationRules: [
    depthLimit(5)  // 최대 5단계까지만 허용
  ]
});

// 3. 필드 레벨 인증
const resolvers = {
  User: {
    email: (user, args, context) => {
      // 본인 또는 관리자만 이메일 조회 가능
      if (context.user?.id !== user.id && !context.user?.isAdmin) {
        return null;  // 또는 에러 throw
      }
      return user.email;
    },
    
    privateData: (user, args, context) => {
      if (!context.user) {
        throw new Error('Authentication required');
      }
      if (context.user.id !== user.id) {
        throw new Error('Unauthorized');
      }
      return user.privateData;
    }
  }
};

// 4. Persisted Queries (허용된 쿼리만 실행)
const persistedQueries = {
  'hash123': 'query GetUser($id: ID!) { user(id: $id) { name } }',
  'hash456': 'query GetPosts { posts { title } }'
};

const server = new ApolloServer({
  typeDefs,
  resolvers,
  plugins: [{
    requestDidStart() {
      return {
        didResolveOperation({ request, operation }) {
          if (!persistedQueries[request.extensions?.persistedQuery?.sha256Hash]) {
            throw new Error('Query not allowed');
          }
        }
      };
    }
  }]
});

// REST API를 래핑하는 GraphQL 리졸버
const resolvers = {
  Query: {
    user: async (parent, { id }) => {
      const response = await fetch(`${REST_API_URL}/users/${id}`);
      return response.json();
    },
    
    posts: async (parent, { userId }) => {
      const response = await fetch(
        `${REST_API_URL}/users/${userId}/posts`
      );
      return response.json();
    }
  }
};

// tRPC 예제
// 서버
const appRouter = router({
  getUser: publicProcedure
    .input(z.object({ id: z.string() }))
    .query(({ input }) => {
      return db.user.findById(input.id);
    }),
});

// 클라이언트 (자동 타입 추론!)
const user = await trpc.getUser.query({ id: '123' });
// user의 타입이 자동으로 추론됨

// 사용자 서비스
type User @key(fields: "id") {
  id: ID!
  name: String!
}

// 주문 서비스
extend type User @key(fields: "id") {
  id: ID! @external
  orders: [Order!]!
}