GET /api/users/123
GET /api/users/123/posts?limit=3
GET /api/users/123/followers/count

query {
  user(id: 123) {
    name
    profileImage
    posts(limit: 3) {
      title
      createdAt
    }
    followersCount
  }
}

gem 'graphql', '~> 2.0'
gem 'graphiql-rails', group: :development

bundle install
rails generate graphql:install

# app/graphql/types/user_type.rb
module Types
  class UserType < Types::BaseObject
    description "블로그 사용자"
    
    field :id, ID, null: false
    field :name, String, null: false
    field :email, String, null: false
    field :created_at, GraphQL::Types::ISO8601DateTime, null: false
    field :posts, [Types::PostType], null: true
    field :followers_count, Integer, null: false
    
    def followers_count
      object.followers.count
    end
  end
end

# app/graphql/types/query_type.rb
module Types
  class QueryType < Types::BaseObject
    # 단일 사용자 조회
    field :user, UserType, null: true do
      argument :id, ID, required: true
    end
    
    def user(id:)
      User.find_by(id: id)
    end
    
    # 모든 사용자 조회
    field :users, [UserType], null: false do
      argument :limit, Integer, required: false, default_value: 10
    end
    
    def users(limit:)
      User.limit(limit)
    end
    
    # 현재 로그인한 사용자
    field :current_user, UserType, null: true
    
    def current_user
      context[:current_user]
    end
  end
end

# app/graphql/mutations/create_user.rb
module Mutations
  class CreateUser < BaseMutation
    description "새로운 사용자 생성"
    
    # 입력 필드
    argument :name, String, required: true
    argument :email, String, required: true
    argument :password, String, required: true
    
    # 반환 필드
    field :user, Types::UserType, null: true
    field :errors, [String], null: false
    
    def resolve(name:, email:, password:)
      user = User.new(
        name: name,
        email: email,
        password: password
      )
      
      if user.save
        {
          user: user,
          errors: []
        }
      else
        {
          user: nil,
          errors: user.errors.full_messages
        }
      end
    end
  end
end

query {
  users {
    name
    posts {
      title
    }
  }
}

# Gemfile
gem 'graphql-batch'

# app/graphql/loaders/record_loader.rb
class RecordLoader < GraphQL::Batch::Loader
  def initialize(model)
    @model = model
  end
  
  def perform(ids)
    @model.where(id: ids).each { |record| fulfill(record.id, record) }
    ids.each { |id| fulfill(id, nil) unless fulfilled?(id) }
  end
end

# Type에서 사용
field :posts, [Types::PostType], null: true

def posts
  RecordLoader.for(Post).load_many(object.post_ids)
end

# app/graphql/mutations/base_mutation.rb
module Mutations
  class BaseMutation < GraphQL::Schema::Mutation
    def ready?(**args)
      if context[:current_user].nil?
        raise GraphQL::ExecutionError, "로그인이 필요합니다"
      end
      true
    end
  end
end

# 특정 권한 체크
class DeletePost < BaseMutation
  argument :id, ID, required: true
  
  field :success, Boolean, null: false
  
  def resolve(id:)
    post = Post.find(id)
    
    unless post.user_id == context[:current_user].id
      raise GraphQL::ExecutionError, "권한이 없습니다"
    end
    
    { success: post.destroy }
  end
end

# app/graphql/types/query_type.rb
field :posts, Types::PostType.connection_type, null: false do
  argument :first, Integer, required: false
  argument :after, String, required: false
end

def posts(first: 10, after: nil)
  Post.all
end

query {
  posts(first: 10, after: "cursor123") {
    edges {
      node {
        id
        title
      }
      cursor
    }
    pageInfo {
      hasNextPage
      endCursor
    }
  }
}

# app/graphql/types/subscription_type.rb
class Types::SubscriptionType < GraphQL::Schema::Object
  field :message_added, Types::MessageType, null: false do
    argument :room_id, ID, required: true
  end
  
  def message_added(room_id:)
    # 구독 설정
  end
end

# 메시지 생성 시 트리거
class CreateMessage < BaseMutation
  def resolve(room_id:, content:)
    message = Message.create!(room_id: room_id, content: content)
    
    # 구독자들에게 알림
    YourSchema.subscriptions.trigger(
      'messageAdded',
      { room_id: room_id },
      message
    )
    
    { message: message }
  end
end

# app/graphql/your_schema.rb
class YourSchema < GraphQL::Schema
  max_complexity 200
  max_depth 10
  
  # 타임아웃 설정
  default_max_page_size 100
end

# 필드별 복잡도 설정
field :posts, [PostType], null: false do
  complexity 5
end

field :expensive_calculation, String, null: false do
  complexity 50
end

# 1. 쿼리 레벨 캐싱
def users
  Rails.cache.fetch("users_list", expires_in: 5.minutes) do
    User.all.to_a
  end
end

# 2. 필드 레벨 캐싱
field :expensive_data, String, null: false

def expensive_data
  Rails.cache.fetch("user_#{object.id}_expensive_data", expires_in: 1.hour) do
    # 복잡한 계산...
    calculate_expensive_data
  end
end

# 3. DataLoader를 활용한 요청 레벨 캐싱
class UserLoader < GraphQL::Batch::Loader
  def perform(ids)
    User.where(id: ids).each { |user| fulfill(user.id, user) }
  end
end

# app/graphql/your_schema.rb
class YourSchema < GraphQL::Schema
  # 쿼리 실행 시간 측정
  trace_with GraphQL::Tracing::NewRelicTracing
  
  # 또는 커스텀 트레이싱
  trace_with CustomTracer
end

class CustomTracer < GraphQL::Tracing::PlatformTracing
  def platform_trace(platform_key, key, data)
    start_time = Time.now
    result = yield
    duration = Time.now - start_time
    
    Rails.logger.info "GraphQL #{key}: #{duration}s"
    result
  end
end

class YourSchema < GraphQL::Schema
  # 프로덕션에서 Introspection 비활성화
  disable_introspection_entry_points if Rails.env.production?
  
  # 또는 조건부 허용
  def self.introspection_enabled?
    context = Thread.current[:graphql_context]
    context[:current_user]&.admin?
  end
end

class UserType < Types::BaseObject
  field :email, String, null: false
  
  def email
    # 본인 또는 관리자만 이메일 조회 가능
    if context[:current_user]&.id == object.id || context[:current_user]&.admin?
      object.email
    else
      raise GraphQL::ExecutionError, "접근 권한이 없습니다"
    end
  end
  
  # 또는 더 깔끔하게
  field :email, String, null: false do
    authorize :read_email
  end
end

# Rack::Attack 사용
class Application < Rails::Application
  config.middleware.use Rack::Attack
end

# config/initializers/rack_attack.rb
Rack::Attack.throttle('graphql/ip', limit: 100, period: 1.minute) do |req|
  req.ip if req.path == '/graphql'
end

# 사용자별 제한
Rack::Attack.throttle('graphql/user', limit: 500, period: 1.hour) do |req|
  if req.path == '/graphql'
    # JWT 토큰에서 사용자 ID 추출
    extract_user_id(req)
  end
end

// Apollo Client 설정
import { ApolloClient, InMemoryCache, ApolloProvider } from '@apollo/client';

const client = new ApolloClient({
  uri: 'http://localhost:3000/graphql',
  cache: new InMemoryCache(),
  headers: {
    authorization: `Bearer ${localStorage.getItem('token')}`
  }
});

// React 컴포넌트에서 사용
import { useQuery, gql } from '@apollo/client';

const GET_USERS = gql`
  query GetUsers {
    users {
      id
      name
      email
      posts {
        title
      }
    }
  }
`;

function UserList() {
  const { loading, error, data } = useQuery(GET_USERS);
  
  if (loading) return <p>로딩 중...</p>;
  if (error) return <p>에러 발생: {error.message}</p>;
  
  return (
    <div>
      {data.users.map(user => (
        <div key={user.id}>
          <h3>{user.name}</h3>
          <p>{user.email}</p>
          <p>게시글 수: {user.posts.length}</p>
        </div>
      ))}
    </div>
  );
}

import { useMutation, gql } from '@apollo/client';

const CREATE_USER = gql`
  mutation CreateUser($name: String!, $email: String!, $password: String!) {
    createUser(input: {
      name: $name
      email: $email
      password: $password
    }) {
      user {
        id
        name
        email
      }
      errors
    }
  }
`;

function SignupForm() {
  const [createUser, { loading, error }] = useMutation(CREATE_USER);
  
  const handleSubmit = async (e) => {
    e.preventDefault();
    const formData = new FormData(e.target);
    
    try {
      const { data } = await createUser({
        variables: {
          name: formData.get('name'),
          email: formData.get('email'),
          password: formData.get('password')
        }
      });
      
      if (data.createUser.errors.length === 0) {
        alert('회원가입 성공!');
      } else {
        alert(data.createUser.errors.join(', '));
      }
    } catch (err) {
      console.error('에러:', err);
    }
  };
  
  return (
    <form onSubmit={handleSubmit}>
      <input name="name" placeholder="이름" required />
      <input name="email" type="email" placeholder="이메일" required />
      <input name="password" type="password" placeholder="비밀번호" required />
      <button type="submit" disabled={loading}>
        {loading ? '처리 중...' : '가입하기'}
      </button>
    </form>
  );
}

import { useSubscription, gql } from '@apollo/client';

const MESSAGE_SUBSCRIPTION = gql`
  subscription OnMessageAdded($roomId: ID!) {
    messageAdded(roomId: $roomId) {
      id
      content
      user {
        name
      }
      createdAt
    }
  }
`;

function ChatRoom({ roomId }) {
  const { data, loading } = useSubscription(MESSAGE_SUBSCRIPTION, {
    variables: { roomId }
  });
  
  if (loading) return <p>연결 중...</p>;
  
  return (
    <div>
      <p>새 메시지: {data.messageAdded.content}</p>
      <p>보낸 사람: {data.messageAdded.user.name}</p>
    </div>
  );
}

# spec/graphql/queries/users_query_spec.rb
require 'rails_helper'

RSpec.describe 'Users Query', type: :request do
  describe 'users' do
    let!(:users) { create_list(:user, 3) }
    
    let(:query) do
      <<~GQL
        query {
          users {
            id
            name
            email
          }
        }
      GQL
    end
    
    it '모든 사용자를 반환한다' do
      post '/graphql', params: { query: query }
      
      json = JSON.parse(response.body)
      data = json['data']['users']
      
      expect(data.length).to eq(3)
      expect(data.first['name']).to eq(users.first.name)
    end
  end
  
  describe 'user(id:)' do
    let(:user) { create(:user) }
    
    let(:query) do
      <<~GQL
        query($id: ID!) {
          user(id: $id) {
            id
            name
            email
          }
        }
      GQL
    end
    
    it '특정 사용자를 반환한다' do
      post '/graphql', params: { 
        query: query, 
        variables: { id: user.id }
      }
      
      json = JSON.parse(response.body)
      data = json['data']['user']
      
      expect(data['id']).to eq(user.id.to_s)
      expect(data['name']).to eq(user.name)
    end
  end
end

# spec/graphql/mutations/create_user_spec.rb
require 'rails_helper'

RSpec.describe Mutations::CreateUser, type: :request do
  let(:mutation) do
    <<~GQL
      mutation($name: String!, $email: String!, $password: String!) {
        createUser(input: {
          name: $name
          email: $email
          password: $password
        }) {
          user {
            id
            name
            email
          }
          errors
        }
      }
    GQL
  end
  
  context '유효한 입력일 때' do
    let(:variables) do
      {
        name: 'John Doe',
        email: 'john@example.com',
        password: 'password123'
      }
    end
    
    it '사용자를 생성한다' do
      expect {
        post '/graphql', params: { query: mutation, variables: variables }
      }.to change(User, :count).by(1)
      
      json = JSON.parse(response.body)
      data = json['data']['createUser']
      
      expect(data['user']['name']).to eq('John Doe')
      expect(data['errors']).to be_empty
    end
  end
  
  context '유효하지 않은 입력일 때' do
    let(:variables) do
      {
        name: '',
        email: 'invalid-email',
        password: '123'
      }
    end
    
    it '에러를 반환한다' do
      post '/graphql', params: { query: mutation, variables: variables }
      
      json = JSON.parse(response.body)
      data = json['data']['createUser']
      
      expect(data['user']).to be_nil
      expect(data['errors']).not_to be_empty
    end
  end
end

# 상품 상세 페이지 쿼리 예시
query ProductPage($handle: String!) {
  productByHandle(handle: $handle) {
    id
    title
    description
    priceRange {
      minVariantPrice {
        amount
        currencyCode
      }
    }
    images(first: 5) {
      edges {
        node {
          url
          altText
        }
      }
    }
    variants(first: 10) {
      edges {
        node {
          id
          title
          price
          availableForSale
          selectedOptions {
            name
            value
          }
        }
      }
    }
    reviews(first: 5) {
      edges {
        node {
          rating
          content
          author {
            name
          }
        }
      }
    }
  }
}

# 사용자 프로필용
query UserProfile {
  currentUser {
    id
    name
    email
    postsCount
    followersCount
  }
}

# 게시글 목록용
query UserPosts($userId: ID!) {
  user(id: $userId) {
    posts(first: 10) {
      edges {
        node {
          id
          title
          commentsCount
        }
      }
    }
  }
}

# 나쁜 예 - N+1 발생
class UserType < Types::BaseObject
  field :posts, [PostType], null: true
  
  def posts
    object.posts  # 각 사용자마다 별도 쿼리 실행!
  end
end

# 좋은 예 - Eager Loading
class QueryType < Types::BaseObject
  field :users, [UserType], null: false
  
  def users
    User.includes(:posts)  # 미리 로드!
  end
end

// 나쁜 예
const { data } = await client.query({ query: GET_USERS });
console.log(data.users);  // data가 null일 수 있음!

// 좋은 예
const { data, errors } = await client.query({ query: GET_USERS });

if (errors) {
  console.error('GraphQL 에러:', errors);
  // 에러 처리 로직
  return;
}

if (!data || !data.users) {
  console.error('데이터가 없습니다');
  return;
}

console.log(data.users);

# 나쁜 예
field :created_at, String, null: true  # 문자열? 날짜?

# 좋은 예
field :created_at, GraphQL::Types::ISO8601DateTime, null: false
field :status, Types::PostStatusEnum, null: false  # Enum 사용
field :tags, [String], null: false  # 배열임을 명확히

query {
  user(id: "123") {
    name
    email
    ... @defer {
      posts {
        title
        content
      }
    }
  }
}

# config/routes.rb
Rails.application.routes.draw do
  # 기존 REST API는 유지
  namespace :api do
    namespace :v1 do
      resources :users
      resources :posts
    end
  end
  
  # GraphQL은 별도 엔드포인트로
  post "/graphql", to: "graphql#execute"
  
  if Rails.env.development?
    mount GraphiQL::Rails::Engine, at: "/graphiql", graphql_path: "/graphql"
  end
end

# 개발 환경에서 쿼리 로깅
class YourSchema < GraphQL::Schema
  if Rails.env.development?
    trace_with GraphQL::Tracing::ActiveSupportNotificationsTracing
  end
end

# config/initializers/graphql_logging.rb
ActiveSupport::Notifications.subscribe("execute_query.graphql") do |*args|
  event = ActiveSupport::Notifications::Event.new(*args)
  Rails.logger.info "GraphQL Query (#{event.duration.round(2)}ms): #{event.payload[:query]}"
end