home / skills / ntaksh42 / agents / graphql-schema-generator

graphql-schema-generator skill

/.claude/skills/graphql-schema-generator

This skill generates GraphQL schemas, resolvers, and type definitions from data models, enabling rapid API design and automatic documentation.

npx playbooks add skill ntaksh42/agents --skill graphql-schema-generator

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.4 KB
---
name: graphql-schema-generator
description: Generate GraphQL schemas, resolvers, and type definitions. Use when designing GraphQL APIs or documenting GraphQL schemas.
---

# GraphQL Schema Generator Skill

GraphQLスキーマを生成するスキルです。

## 概要

データモデルからGraphQLスキーマ、リゾルバーを自動生成します。

## 主な機能

- **スキーマ定義**: Type、Query、Mutation
- **リゾルバー生成**: 実装テンプレート
- **ベストプラクティス**: ページネーション、エラーハンドリング
- **ドキュメント**: 自動生成

## 生成例

### Schema

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

type Post {
  id: ID!
  title: String!
  content: String!
  author: User!
  published: Boolean!
  createdAt: DateTime!
  updatedAt: DateTime!
}

type Query {
  user(id: ID!): User
  users(first: Int = 10, after: String): UserConnection!
  post(id: ID!): Post
  posts(published: Boolean): [Post!]!
}

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

# Inputs
input CreateUserInput {
  name: String!
  email: String!
  password: String!
}

input UpdateUserInput {
  name: String
  email: String
}

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

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

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

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

# Custom Scalars
scalar DateTime
```

### Resolvers (JavaScript)

```javascript
const resolvers = {
  Query: {
    user: async (parent, { id }, { dataSources }) => {
      return dataSources.userAPI.getUserById(id);
    },
    users: async (parent, { first, after }, { dataSources }) => {
      return dataSources.userAPI.getUsers({ first, after });
    },
    post: async (parent, { id }, { dataSources }) => {
      return dataSources.postAPI.getPostById(id);
    },
    posts: async (parent, { published }, { dataSources }) => {
      return dataSources.postAPI.getPosts({ published });
    }
  },

  Mutation: {
    createUser: async (parent, { input }, { dataSources }) => {
      return dataSources.userAPI.createUser(input);
    },
    updateUser: async (parent, { id, input }, { dataSources }) => {
      return dataSources.userAPI.updateUser(id, input);
    },
    deleteUser: async (parent, { id }, { dataSources }) => {
      return dataSources.userAPI.deleteUser(id);
    },
    createPost: async (parent, { input }, { dataSources, user }) => {
      if (!user) throw new Error('Unauthorized');
      return dataSources.postAPI.createPost(input);
    },
    publishPost: async (parent, { id }, { dataSources, user }) => {
      if (!user) throw new Error('Unauthorized');
      return dataSources.postAPI.publishPost(id);
    }
  },

  User: {
    posts: async (parent, args, { dataSources }) => {
      return dataSources.postAPI.getPostsByAuthor(parent.id);
    }
  },

  Post: {
    author: async (parent, args, { dataSources }) => {
      return dataSources.userAPI.getUserById(parent.authorId);
    }
  }
};
```

## バージョン情報

- スキルバージョン: 1.0.0

Overview

This skill generates complete GraphQL schemas, resolver templates, and type definitions from data models and API requirements. It produces Type, Query, Mutation, input objects, connection/pagination types, and common custom scalars. The output is geared toward practical server implementations and documentation.

How this skill works

Provide your data model or resource descriptions and the skill maps fields to GraphQL types and generates corresponding Query and Mutation definitions. It scaffolds resolver functions with typical data source interactions and authentication checks, and includes pagination, error-handling patterns, and auto-generated documentation. Outputs include schema (SDL) and example resolver code in JavaScript ready for integration.

When to use it

  • Designing a new GraphQL API from an existing data model
  • Scaffolding server-side resolvers and type definitions quickly
  • Standardizing schema patterns like pagination and connections
  • Documenting schema contracts for frontend/backend teams
  • Adding custom scalars and common input types for mutations

Best practices

  • Review and customize generated access control checks to match your auth model
  • Keep input types narrow and validate on both schema and service layers
  • Use generated connection types for consistent pagination across resources
  • Maintain resolver separation: thin resolvers calling well-tested data source methods
  • Adjust generated error handling to expose safe, client-friendly messages only

Example use cases

  • Generate a User and Post schema with queries, mutations, and connection-based pagination
  • Create resolver templates that call existing data sources (REST/DB) with auth stubs
  • Produce input types for create/update operations and scaffold validation points
  • Auto-generate schema documentation for onboarding frontend developers
  • Bootstrap a new service with standard scalars like DateTime and common PageInfo types

FAQ

Can I customize the generated schema output?

Yes. The skill produces editable SDL and resolver templates so you can change field names, add directives, or adapt authentication and validation logic.

What runtimes are supported for resolver examples?

Resolver templates are provided in JavaScript (Node.js) style but the schema (SDL) is runtime-agnostic and can be used with other GraphQL server implementations.