【2026年版】GraphQL vs REST API：選定基準と移行戦略の実践ガイド

query {
  user(id: "123") {
    name
    email
    posts(first: 5) {
      title
      createdAt
      comments {
        body
        author {
          name
        }
      }
    }
  }
}

// REST: 複数リクエストが必要（N+1問題の可能性）
const user = await fetch('/api/users/123');
const posts = await fetch('/api/users/123/posts');
const comments = await Promise.all(
  posts.map(post => fetch(`/api/posts/${post.id}/comments`))
);

// GraphQL: 1回のリクエストで完結
const { data } = await client.query({
  query: gql`
    query GetUserWithPosts {
      user(id: "123") {
        name
        email
        posts {
          title
          comments {
            body
          }
        }
      }
    }
  `
});

// Apollo Clientの正規化キャッシュ
const client = new ApolloClient({
  cache: new InMemoryCache({
    typePolicies: {
      User: {
        keyFields: ["id"],
      },
      Post: {
        keyFields: ["id"],
      },
    },
  }),
});

# GraphQL スキーマ定義
type User {
  id: ID!
  name: String!
  email: String!
  role: UserRole!
  posts(first: Int, after: String): PostConnection!
  createdAt: DateTime!
}

enum UserRole {
  ADMIN
  EDITOR
  VIEWER
}

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

# OpenAPI 3.0
components:
  schemas:
    User:
      type: object
      required:
        - id
        - name
        - email
      properties:
        id:
          type: string
          format: uuid
        name:
          type: string
        email:
          type: string
          format: email
        role:
          type: string
          enum: [admin, editor, viewer]

import { ApolloServer } from '@apollo/server';
import { startStandaloneServer } from '@apollo/server/standalone';

// スキーマ定義
const typeDefs = `#graphql
  type Query {
    users(first: Int, after: String): UserConnection!
    user(id: ID!): User
  }

  type Mutation {
    createUser(input: CreateUserInput!): User!
    updateUser(id: ID!, input: UpdateUserInput!): User!
    deleteUser(id: ID!): Boolean!
  }

  type Subscription {
    userCreated: User!
  }

  input CreateUserInput {
    name: String!
    email: String!
    role: UserRole!
  }

  input UpdateUserInput {
    name: String
    email: String
    role: UserRole
  }

  type User {
    id: ID!
    name: String!
    email: String!
    role: UserRole!
    posts: [Post!]!
    createdAt: String!
  }

  enum UserRole {
    ADMIN
    EDITOR
    VIEWER
  }

  type Post {
    id: ID!
    title: String!
    body: String!
    author: User!
  }

  type UserConnection {
    edges: [UserEdge!]!
    pageInfo: PageInfo!
    totalCount: Int!
  }

  type UserEdge {
    node: User!
    cursor: String!
  }

  type PageInfo {
    hasNextPage: Boolean!
    endCursor: String
  }
`;

// リゾルバー定義
const resolvers = {
  Query: {
    users: async (_, { first, after }, { dataSources }) => {
      return dataSources.userAPI.getUsers({ first, after });
    },
    user: async (_, { id }, { dataSources }) => {
      return dataSources.userAPI.getUser(id);
    },
  },
  User: {
    posts: async (parent, _, { dataSources }) => {
      // DataLoaderパターンでN+1問題を解決
      return dataSources.postLoader.load(parent.id);
    },
  },
  Mutation: {
    createUser: async (_, { input }, { dataSources }) => {
      return dataSources.userAPI.createUser(input);
    },
  },
};

const server = new ApolloServer({ typeDefs, resolvers });

const { url } = await startStandaloneServer(server, {
  listen: { port: 4000 },
  context: async ({ req }) => ({
    dataSources: {
      userAPI: new UserAPI(),
      postLoader: createPostLoader(),
    },
    token: req.headers.authorization,
  }),
});

import DataLoader from 'dataloader';

// バッチ処理でN+1問題を解決
const createPostLoader = () => {
  return new DataLoader(async (userIds: readonly string[]) => {
    const posts = await db.post.findMany({
      where: { authorId: { in: [...userIds] } },
    });
    // userIdごとにグループ化して返す
    const postsByUserId = new Map<string, Post[]>();
    posts.forEach(post => {
      const existing = postsByUserId.get(post.authorId) || [];
      existing.push(post);
      postsByUserId.set(post.authorId, existing);
    });
    return userIds.map(id => postsByUserId.get(id) || []);
  });
};

import depthLimit from 'graphql-depth-limit';
import { createComplexityLimitRule } from 'graphql-validation-complexity';

const server = new ApolloServer({
  typeDefs,
  resolvers,
  validationRules: [
    // クエリの深さを制限
    depthLimit(10),
    // クエリの複雑度を制限
    createComplexityLimitRule(1000, {
      scalarCost: 1,
      objectCost: 10,
      listFactor: 20,
    }),
  ],
  plugins: [
    // クエリタイムアウト
    {
      requestDidStart: async () => ({
        willSendResponse: async ({ response }) => {
          // レスポンスタイムの計測・制限
        },
      }),
    },
  ],
});

// REST APIをGraphQLでラップするリゾルバー
const resolvers = {
  Query: {
    user: async (_, { id }) => {
      // 既存のREST APIを内部的に呼び出す
      const response = await fetch(`http://internal-api/users/${id}`);
      return response.json();
    },
    posts: async (_, { userId }) => {
      const response = await fetch(
        `http://internal-api/users/${userId}/posts`
      );
      return response.json();
    },
  },
};

# ユーザーサービスのスキーマ
type User @key(fields: "id") {
  id: ID!
  name: String!
  email: String!
}

# 投稿サービスのスキーマ
extend type User @key(fields: "id") {
  id: ID! @external
  posts: [Post!]!
}

type Post @key(fields: "id") {
  id: ID!
  title: String!
  body: String!
  author: User!
}

// Express.jsでのREST API最適化例
const express = require('express');
const compression = require('compression');
const rateLimit = require('express-rate-limit');

const app = express();

// Gzip圧縮
app.use(compression());

// レート制限
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15分
  max: 100, // 最大100リクエスト
});
app.use('/api/', limiter);

// レスポンスキャッシュヘッダー
app.get('/api/users/:id', async (req, res) => {
  const user = await getUser(req.params.id);
  res.set('Cache-Control', 'public, max-age=300');
  res.set('ETag', generateETag(user));
  res.json(user);
});

// Persisted Queries（永続化クエリ）
import { ApolloServer } from '@apollo/server';
import {
  ApolloServerPluginPersistedQueries
} from '@apollo/server/plugin/persistedQueries';

const server = new ApolloServer({
  typeDefs,
  resolvers,
  plugins: [
    ApolloServerPluginPersistedQueries({
      // 事前登録されたクエリのみ許可
      cache: new KeyValueCache(),
    }),
  ],
});

// Automatic Persisted Queries (APQ) フロー：
// 1. クライアントがクエリハッシュを送信
// 2. サーバーがキャッシュを確認
// 3. キャッシュミス時にフルクエリを送信
// 4. 以降はハッシュのみで通信