What is a GraphQL relationship edge?

An edge is created whenever a field on one type returns another type defined in the schema. For example, a Post type with an author field of type User produces the edge Post.author to User. These edges form the directed graph of how your types connect.

Does it use the official graphql.js parser?

It uses a focused SDL tokenizer that extracts type, interface, input, enum, union and scalar definitions along with their fields. This keeps the tool dependency-free and fast while covering the constructs needed to map relationships.

How are list and non-null types handled?

A field type such as [Post!]! is shown in full, but for relationship mapping it is reduced to the bare named type Post. List wrappers and the non-null exclamation marks do not change which types are connected.

Why is a field flagged as referencing an unknown type?

That happens when a field returns a name that is neither a built-in scalar (Int, Float, String, Boolean, ID) nor a type defined elsewhere in the pasted schema. It usually means a typo or a missing definition.

Is my schema uploaded anywhere?

No. The schema is parsed locally in your browser using JavaScript. Nothing is sent to a server, so it is safe to inspect private or internal GraphQL schemas.

GraphQL Schema Visualizer

A GraphQL schema written in SDL (Schema Definition Language) declares every type your API exposes and how those types reference one another. As a schema grows, the web of relationships — which type points at which — becomes the hard part to hold in your head. This visualizer parses the SDL and surfaces both the type list and the relationship edges between types.

How it works

The parser first strips descriptions and comments, then extracts definitions with a lightweight tokenizer:

type, interface, and input blocks are read along with their { ... } field bodies; each field’s return type is captured.
enum, union, and scalar definitions are collected with their symbols or members.
For every field whose return type — once stripped of list [ ] and non-null ! wrappers — names another defined type, an edge From.field → To is recorded.

The set of edges is the adjacency list of the schema’s relationship graph: walk it to see how data connects from the root Query outward.

Example

Given:

type Post {
  author: User!
  comments: [Comment!]
}

the visualizer produces two edges — Post.author → User and Post.comments → Comment — because both User and Comment are defined types. A field returning String produces no edge, since String is a built-in scalar.

Notes

The tool also flags any field that references a name which is neither a built-in scalar nor a defined type, catching typos and missing definitions early. It maps structure, not behavior, so it does not execute queries or validate resolver logic — it is a fast way to understand and audit how a schema’s types relate.