GraphQL Fragment Matcher Generator

Report an Issue

Help us improve by telling us what went wrong.

Embed this Tool

Customize and copy the embed code for your website.

What Is a GraphQL Fragment Matcher and Why Do You Need One?

When your GraphQL API uses interfaces and union types, your client library needs a way to figure out which concrete type a response actually contains. Without this information, libraries like Apollo Client can't correctly cache or resolve inline fragments. That's where a fragment matcher comes in - it's a JSON configuration that tells your client about every possible type behind each abstract type in your schema. The GraphQL Fragment Matcher Generator builds this configuration for you automatically.

Traditionally, generating a fragment matcher meant running an introspection query against your live API, piping the result through a script, and extracting the __schema.types data. It's a multi-step process that's easy to get wrong, especially when your schema has dozens of interfaces and unions. This tool collapses that entire process into a single paste-and-generate action.

How the Generator Works

You provide your GraphQL schema - either as SDL (Schema Definition Language) or as the result of an introspection query. The GraphQL Fragment Matcher Generator parses it, identifies all interface and union type definitions, and maps each abstract type to its list of possible concrete types. The output is a properly formatted introspection result fragment that you can drop directly into your Apollo Client configuration.

For Apollo Client 3.x, the output works with InMemoryCache's possibleTypes option. For older versions using IntrospectionFragmentMatcher, the tool produces the legacy format too. Either way, you get code that's ready to use without modification.

The Real-World Problem This Solves

Picture this: you have a SearchResult union type that can be a User, Post, or Comment. Your frontend query uses inline fragments to fetch type-specific fields. Without a fragment matcher, Apollo has no idea that a SearchResult could be a User, so it silently drops the User-specific fields from the cache. Your UI renders incomplete data, and the bug is nearly impossible to diagnose because there are no errors - just missing fields.

This is not a hypothetical scenario. It's one of the most common support issues in the Apollo Client GitHub repository, and the solution is always the same: configure your fragment matcher properly. This generator makes that configuration trivial to produce and maintain.

Keeping Fragment Matchers in Sync with Schema Changes

Schemas change. New types get added to unions, interfaces gain new implementors, and old types get deprecated. Every one of those changes means your fragment matcher needs updating. The GraphQL Fragment Matcher Generator makes updates painless - paste the current schema, regenerate, and replace the old configuration. Some teams even integrate this into their CI pipeline by generating the matcher from the schema file in their repository.

If you maintain multiple GraphQL APIs or microservices that get stitched together, each service's schema may contribute its own interfaces and unions. Regenerating the combined fragment matcher after any service updates its schema ensures your client always has accurate type resolution information.

No Installation, No Build Tools Required

Unlike CLI-based solutions that require graphql-codegen or custom Node scripts, this fragment matcher generator runs entirely in your browser. There's no package to install, no configuration file to write, and no build pipeline to maintain. It's particularly useful during rapid prototyping when you haven't set up code generation infrastructure yet, or when you're debugging a caching issue and need a quick way to verify your possible types mapping.

Your schema data stays local throughout the process. Nothing is sent to a server, which means proprietary schemas remain private. The generation is instant regardless of schema size, because the parsing happens right on your machine.

Stop Debugging Phantom Cache Bugs

Fragment matcher misconfigurations are responsible for some of the most confusing bugs in GraphQL client development. Fields that appear in the network response but vanish from the cache. Components that render stale data despite successful queries. The fix is simple but often overlooked. Use this GraphQL Fragment Matcher Generator every time your schema changes, and those phantom bugs disappear before they start.