JSON to GraphQL Type Generator

JSON to GraphQL Type: Generating Schema Definitions from Existing Data

When building a GraphQL API on top of an existing REST service or database, you often start with JSON responses and need to translate them into GraphQL type definitions. Hand-writing these is error-prone — missing ! on a required field or using String where Int belongs causes runtime errors that only surface at query time. Generating GraphQL types from your JSON gives you an accurate starting schema that reflects your actual data structure.

Live Example: REST Response to GraphQL Types

// Input JSON
{
  "id": "usr_9921",
  "username": "dev_guru",
  "email": "dev@example.com",
  "role": "admin",
  "profile": {
    "bio": "Full-stack engineer",
    "avatar_url": "https://cdn.example.com/avatars/9921.png",
    "followers": 1420
  },
  "tags": ["typescript", "graphql"],
  "last_login": null
}

// Generated GraphQL Types
type Profile {
  bio: String!
  avatar_url: String!
  followers: Float!
}

type Root {
  id: String!
  username: String!
  email: String!
  role: String!
  profile: Profile!
  tags: [String]!
  last_login: String
}

Fields present with a non-null value become non-nullable (!). Fields that are null in the sample are left nullable — exactly what GraphQL clients expect.

Refining the Generated Schema

The generator produces a correct starting point, but GraphQL schemas benefit from a few manual refinements:

Use scalar types where appropriate:

# Before (generated)
type Root {
  id: String!
  email: String!
  created_at: String
}

# After (refined with custom scalars)
scalar DateTime
scalar EmailAddress

type Root {
  id: ID!
  email: EmailAddress!
  created_at: DateTime
}

Replace string enums with GraphQL enums:

# Before
type Root {
  role: String!
  status: String!
}

# After — GraphQL enforces the allowed values
enum UserRole { admin moderator member }
enum UserStatus { active inactive suspended }

type Root {
  role: UserRole!
  status: UserStatus!
}

Split Query, Mutation, and Subscription types: The generated type represents your data shape. You still need to wire it into your schema's type Query, type Mutation, etc.:

type Query {
  user(id: ID!): Root
  users: [Root!]!
}

Working with Nested and Array Types

Nested JSON objects become separate GraphQL types automatically. Arrays become list types. The difference between [String] and [String!]! matters in GraphQL:

# [String]       — the list itself may be null, items may be null
# [String!]      — the list may be null, but items are non-null
# [String]!      — the list is non-null, but items may be null
# [String!]!     — neither the list nor its items can be null

The generator infers nullability from your sample data. If your array always contains non-null strings, you get [String]!. Review and tighten these based on your API contract.

Frequently Asked Questions

Does it generate input types for mutations? The generated types are type definitions (for queries and responses). Input types for mutations are structurally identical but declared with input instead of type — copy the generated type and change the keyword.

How does it handle camelCase vs snake_case? Field names are preserved as-is from your JSON. GraphQL convention is camelCase — rename snake_case fields when refining, or use a resolver to map them.

What about unions and interfaces? The generator does not infer union types or interfaces automatically. If your JSON has a discriminator field (type: "admin" | "user"), refactor the generated type into a GraphQL union manually after generation.

Is my JSON sent to a server? No. Everything runs in your browser. Schema definitions often contain internal field names and data shapes — they never leave your machine.