GraphQL API設計の実践：RESTから移行してクエリ効率を3倍向上させる手法

query {
  users {
    name
    email
  }
}

query {
  posts {
    title
    content
    author {
      name
      email
    }
  }
}

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

type Post {
  id: ID!
  title: String!
  content: String!
  author: User!
  comments: [Comment!]!
  publishedAt: DateTime
}

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

scalar DateTime
scalar Email
scalar URL

type User {
  id: ID!
  email: Email!
  website: URL
  createdAt: DateTime!
}

type Query {
  # 単一リソースの取得
  user(id: ID!): User
  post(id: ID!): Post
  
  # リスト取得（ページネーション対応）
  users(first: Int, after: String): UserConnection!
  posts(first: Int, after: String, authorId: ID): PostConnection!
  
  # 検索
  searchPosts(query: String!, first: Int): [Post!]!
}

input CreatePostInput {
  title: String!
  content: String!
}

type CreatePostPayload {
  post: Post
  errors: [Error!]
}

type Mutation {
  createPost(input: CreatePostInput!): CreatePostPayload!
  updatePost(id: ID!, input: UpdatePostInput!): UpdatePostPayload!
  deletePost(id: ID!): DeletePostPayload!
}

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

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

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

const resolvers = {
  Query: {
    user: async (parent, { id }, context) => {
      // 既存のREST APIを呼び出し
      const response = await fetch('https://api.example.com/users/' + id);
      return response.json();
    },
    posts: async (parent, args, context) => {
      const response = await fetch('https://api.example.com/posts');
      return response.json();
    }
  }
};

const resolvers = {
  Query: {
    user: async (parent, { id }, { dataSources }) => {
      // データベースに直接アクセス
      return dataSources.userDB.findById(id);
    },
    posts: async (parent, { authorId }, { dataSources }) => {
      return dataSources.postDB.findByAuthor(authorId);
    }
  },
  User: {
    posts: async (user, args, { dataSources }) => {
      // N+1問題を解決するDataLoader使用
      return dataSources.postDB.findByAuthorBatch(user.id);
    }
  }
};

const DataLoader = require('dataloader');

const userLoader = new DataLoader(async (userIds) => {
  const users = await db.users.findByIds(userIds);
  // IDの順序を保持して返す
  return userIds.map(id => users.find(user => user.id === id));
});

const resolvers = {
  Post: {
    author: async (post, args, { loaders }) => {
      return loaders.user.load(post.authorId);
    }
  }
};

const { ApolloServer } = require('@apollo/server');
const { startStandaloneServer } = require('@apollo/server/standalone');

const typeDefs = `
  type Query {
    hello: String
    users: [User!]!
  }
  
  type User {
    id: ID!
    name: String!
    email: String!
  }
`;

const resolvers = {
  Query: {
    hello: () => 'Hello, GraphQL!',
    users: async () => {
      return await db.users.findAll();
    }
  }
};

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

startStandaloneServer(server, {
  listen: { port: 4000 },
}).then(({ url }) => {
  console.log('Server ready at ' + url);
});

startStandaloneServer(server, {
  context: async ({ req }) => {
    const token = req.headers.authorization || '';
    const user = await getUserFromToken(token);
    
    return {
      user,
      dataSources: {
        userDB: new UserDataSource(),
        postDB: new PostDataSource(),
      },
      loaders: {
        user: new DataLoader(batchUsers),
        post: new DataLoader(batchPosts),
      }
    };
  },
});

const resolvers = {
  Query: {
    user: async (parent, { id }, { dataSources }) => {
      return dataSources.userDB.findById(id);
    }
  },
  User: {
    // 計算フィールド
    fullName: (user) => {
      return user.firstName + ' ' + user.lastName;
    },
    // 関連データの取得
    posts: async (user, args, { loaders }) => {
      return loaders.post.load(user.id);
    },
    // 条件付きフィールド
    email: (user, args, { user: currentUser }) => {
      // 自分のメールアドレスのみ表示
      if (user.id === currentUser?.id) {
        return user.email;
      }
      return null;
    }
  }
};

const { GraphQLError } = require('graphql');

const resolvers = {
  Mutation: {
    createPost: async (parent, { input }, { user, dataSources }) => {
      if (!user) {
        throw new GraphQLError('認証が必要です', {
          extensions: { code: 'UNAUTHENTICATED' }
        });
      }
      
      try {
        const post = await dataSources.postDB.create({
          ...input,
          authorId: user.id
        });
        return { post, errors: [] };
      } catch (error) {
        return {
          post: null,
          errors: [{
            message: error.message,
            code: 'CREATE_FAILED'
          }]
        };
      }
    }
  }
};

const jwt = require('jsonwebtoken');

const getUserFromToken = async (token) => {
  if (!token) return null;
  
  try {
    const decoded = jwt.verify(token.replace('Bearer ', ''), process.env.JWT_SECRET);
    return await db.users.findById(decoded.userId);
  } catch (error) {
    return null;
  }
};

directive @auth(requires: Role = USER) on OBJECT | FIELD_DEFINITION

enum Role {
  ADMIN
  USER
  GUEST
}

type Query {
  users: [User!]! @auth(requires: ADMIN)
  me: User @auth(requires: USER)
}

const depthLimit = require('graphql-depth-limit');

const server = new ApolloServer({
  typeDefs,
  resolvers,
  validationRules: [depthLimit(5)]
});

const { createComplexityLimitRule } = require('graphql-validation-complexity');

const server = new ApolloServer({
  typeDefs,
  resolvers,
  validationRules: [
    createComplexityLimitRule(1000, {
      scalarCost: 1,
      objectCost: 10,
      listFactor: 10
    })
  ]
});

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

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15分
  max: 100, // 最大100リクエスト
  message: 'リクエスト数が上限に達しました'
});

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

const { KeyvAdapter } = require('@apollo/utils.keyvadapter');
const Keyv = require('keyv');

const server = new ApolloServer({
  typeDefs,
  resolvers,
  cache: new KeyvAdapter(new Keyv('redis://localhost:6379')),
});

const server = new ApolloServer({
  typeDefs,
  resolvers,
  plugins: [
    ApolloServerPluginUsageReporting({
      sendVariableValues: { all: true },
    }),
  ],
});

const server = new ApolloServer({
  typeDefs,
  resolvers,
  plugins: [{
    async requestDidStart() {
      return {
        async didResolveOperation(requestContext) {
          console.log('Query:', requestContext.operationName);
        },
        async willSendResponse(requestContext) {
          console.log('Response time:', Date.now() - requestContext.request.http.headers.get('x-start-time'));
        }
      };
    }
  }]
});