Blog

Understanding GraphQL Federation Versions (V1, V1.5, and V2)

Learn the key differences between GraphQL Federation V1, V1.5, and V2. Understand how entities, value types, and directives like @external and @shareable evolved, and how routers interpret subgraphs across versions for composition compatibility.

Cosmo Connect vs Apollo Federation vs GraphQL Federation

Head-to-head comparison of Cosmo Connect, Apollo Federation, and GraphQL Federation—how they model entities, handle batching, and what that means for operations.

A GraphQL Federation directive for Subgraph-level compliance: @openfed__requireFetchReasons

The @requires directive in GraphQL Federation can leak sensitive fields. See how @openfed__requireFetchReasons improves security, compliance, and audit readiness.

Cosmo Connect Tutorials for Router Plugins and gRPC Services

Step-by-step tutorials for Cosmo Connect: build Router Plugins, deploy gRPC services, and integrate subgraphs into a federated GraphQL API.

The Evolution of GraphQL Federation and the Entity Layer

How GraphQL evolved from monoliths to Schema Stitching to Federation, and why the Entity Layer has become the foundation for unified APIs.

Cosmo Connect: Federation Made Accessible

Cosmo Connect lets backends use gRPC while frontends see one GraphQL API, lowering the barrier to federation across teams and languages.

The Future of GraphQL Federation

A crosspost of Curtis Layne’s deep dive into the architectural tradeoffs of Apollo Federation and the path toward simpler, faster, more scalable approaches to GraphQL Federation.

Behind the Counter: How Cosmo Works

Ever wonder how GraphQL federation works in practice? This story-driven guide uses a food truck park to explain Cosmo’s role in schema composition and routing.

The Future of Federation: Replacing GraphQL Subgraphs with gRPC Services

Why WunderGraph is moving Federation beyond GraphQL Subgraphs to enable simpler, faster, type-safe APIs using gRPC under the hood.

The Next Generation of GraphQL Federation Speaks gRPC

Implement GraphQL Federation with gRPC: compile Subgraph SDLs to type-safe services with built-in data loading and zero N+1 issues.

REST in Peace—Connectors Were Never the Right Supergraph Abstraction

Learn how we use LLMs to automate API integration with a single prompt—cutting implementation costs by 99%.

Scaling GraphQL Federation: Inside Cosmo’s Food Park

Explore GraphQL federation through the lens of a food truck park. A story-driven guide to core concepts, tradeoffs, and how federation helps systems scale.

We accidentally built a backend framework for LLMs

While simplifying API orchestration, we accidentally built a backend framework for LLMs—powered by Cosmo Plugins and GraphQL Federation.

When to Migrate from Cosmo OSS

Cosmo OSS is a great way to start. But when scale, governance, and compliance become blockers, here’s how to know it’s time to move to Cosmo Enterprise.

Golang sync.WaitGroup: Powerful, but tricky

Learn how to use Go’s sync.WaitGroup correctly with real-world examples, common mistakes, and performance tips. Avoid deadlocks, leaks, and master goroutine management.

Why AI Needs A Common Language

Discover how AI systems need structured protocols for effective collaboration. Learn about Model Context Protocol (MCP), agent-to-agent communication, and why natural language alone will not scale for AI interactions. Essential reading for AI developers and API architects.

Rethinking API Access in the Age of AI Agents

Traditional rate limiting doesn’t protect against misuse by AI agents. Discover how harm limiting offers a new, proactive approach to secure API access.

The Impact of MCP and LLMs on Software Development - A Practical Example

See how Model Context Protocol enables LLMs to complete real dev tasks like schema exploration, query generation, and router config—all in a single prompt.

Cosmo MCP: Agent Mode now handles all the boring parts of GraphQL Federation (Right in your IDE)

Use Cosmo MCP with Cursor, Windsurf, or VSCode to automate schema changes, query validation, and router config—right from your IDE, no CLI juggling required.

Query Plan Regression Testing in GraphQL Federation

Discover how we built automated quality checks for GraphQL Federation that catch breaking changes before they hit production. Learn about our query plan testing tools and GitHub workflows that help maintain reliability at scale.

Golang Sync.Pool | Memory Pool Example

Understand how Go’s sync.Pool affects memory usage in high-throughput systems. Learn when pooling helps, when it hurts, and how to use it safely for performance optimization.

Why we couldn't resist raising from eBay - our Series A announcement

From near shutdown to strategic investment by eBay, this is how WunderGraph’s open-source GraphQL Federation platform became the future of enterprise APIs.

@inaccessible Keys in Federated GraphQL APIs - A Deep Dive

The @inaccessible directive in GraphQL Federation allows you to hide keys from the public and manage sensitive data access in your federated GraphQL API.

Syncing Up in Bretten: Day 1

The WunderGraph team gets together in Bretten, Germany to work together.

GraphQL Federation Architecture: Open/Closed Principle & Project-Based SuperGraphs

Learn how GraphQL Federation enables the Open/Closed Principle in API design. Discover SuperGraphs, subgraph reuse, and why REST struggles with extensibility.

Supergraph Kickoff: Scaling Your Federated GraphQL for the Super Bowl

Discover how to prep your GraphQL Federation for Super Bowl-scale traffic with Cosmo Router’s cache warm-up strategy and tips to eliminate cold starts.

Introducing the @configureDescription directive for GraphQL Federation

Fine-tune GraphQL Federation schema composition with @openfed__configureDescription. Control which descriptions appear—and which do not.

How Normalization affects Query Plan Caching in GraphQL Federation

Explore how normalization boosts query plan cache hits in GraphQL Federation. Learn about three normalization forms and how they improve performance and analytics.

Is gRPC Really Better for Microservices Than GraphQL?

Compare gRPC and GraphQL for microservices. Exploring strengths, weaknesses, and when to use each for performance, flexibility, and real-time needs

Expr Lang: Go centric expression language for dynamic configurations

Learn how Cosmo Router uses Expr Lang to power flexible, secure GraphQL configuration without code changes. Explore realf use cases like rate limiting and migrations.

Are Connectors the path forward for GraphQL Federation?

Are connectors the right choice for GraphQL Federation? This deep dive explores their pros, cons, and impact on performance, testing, and schema design.

I was wrong about GraphQL

After 6 years building GraphQL tools, I’m revisiting past opinions to reflect on how experience has reshaped my views on APIs, federation, and tooling.

A Comprehensive Overview of GraphQL Federation in Open Source

Explore GraphQL Federation in open source—how it enables modular APIs with Subgraphs, boosts dev velocity, and scales API infrastructure.

How to align Open Source and Enterprise Sales

Learn how WunderGraph aligns Open Source and Enterprise Sales without feature-gating. Balancing community trust and commercial success the right way.

Live from the GraphQL Conf: The State of Distributed GraphQL 2024

Learn about the state of distributed GraphQL in 2024 and explore some of the exciting developments that are happening in this space. This is an update on GraphQL Federation, the work of the GraphQL Foundation, and the Composite Schema Working Group.

Zero-Cost Abstractions for @skip and @include in Federated GraphQL

Using @skip and @include in GraphQL federation can hurt performance—learn how Cosmo Router's zero-cost abstraction removes overhead and boosts speed.

Graph Feature Flags: Fast and Safe GraphQL Federation Schema Evolution

Learn how Graph Feature Flags in Cosmo enable safe schema evolution and gradual rollouts in GraphQL Federation. Test features and ship faster with full control.

99% Smaller GraphQL Queries with AST Minification

Speed up GraphQL Federation by 25% with AST Minification. Learn how Cosmo Router generates smaller queries and outperforms Apollo in Subgraph execution.

Designing a Multi-Tenant Federated GraphQL Schema

Designing a multi-tenant federated GraphQL schema is a challenge. Let's explore the different approaches to multi-tenancy in a federated GraphQL API.

Cosmo OSS Schema Registry Compatibility Mode for Apollo Router and Gateway

Run Apollo Router or Gateway with Cosmo OSS as your open-source schema registry. Fully compatible with Apollo Federation and ideal for gradual migration.

SSO Just Got Better: OpenID Connect + SCIM for Identity Management

Learn how combining SCIM and OpenID Connect upgrades your SSO. Automate user provisioning, boost security, and streamline identity management at scale.

Distributed GraphQL Subscriptions with NATS and Event Driven Architecture

Learn how to leverage NATS and Event Driven Architecture to build distributed GraphQL Subscriptions.

When to use GraphQL vs Federation vs tRPC vs REST vs gRPC vs AsyncAPI vs WebHooks - A 2024 Comparison

Exploring 2.5 Reasons People Embrace GraphQL in 2024, and the Caveats Behind Its Non-Adoption

Implementing the Viewer Pattern in Federated GraphQL APIs

The Viewer Pattern is a popular way to model GraphQL APIs around a 'viewer'. This article explains how the pattern can be implemented and what benefits it brings for federated GraphQL APIs.

Rate Limiting GraphQL Federation with Cosmo Router & Redis

Learn how to protect your federated GraphQL API from abuse and DDoS attacks by implementing effective, centralized rate limiting with Cosmo Router and Redis.

Why you should avoid exhaustive switch case in API clients

Avoid exhaustive switch cases in API clients — they break forward compatibility and reveal deeper API design flaws you might miss.

Announcing Field Level Authorization for GraphQL Federation with Cosmo Router

Effective Integration Testing for Distributed Systems: Mastering Cosmo Router with GraphQL Federation

Discover the art of integration testing for distributed systems through our in-depth guide. Learn how to expertly test the Cosmo Router using advanced techniques in GraphQL Federation, including the utilization of subgraphs and subscriptions, to ensure seamless end-to-end functionality, correctness and superior system performance.

Scaling GraphQL Subscriptions in Go with Epoll and Event Driven Architecture

Learn how we're leveraging Epoll/Kqueue and Event-Driven Architecture to scale GraphQL Subscriptions in Go. We've reduced the number of goroutines by 99% and the memory consumption by 90% without sacrificing performance.

Announcing EDFS - Event Driven Federated Subscriptions

Event Driven Federated Subscriptions or EDFS for short is a new way to build federated GraphQL Subscriptions. It is based on the Event Driven Architecture (EDA) pattern and allows you to build highly scalable Event-Driven GraphQL APIs on top of Kafka, NATS, SQS, RabbitMQ and more.

Native Subscriptions with Cosmo Router

How an event-based approach makes GraphQL Subscriptions better in Federation.

GraphQL Federation Field-level Metrics 101

Explore how field-level metrics in federated GraphQL help debug faster, cut costs, and optimize APIs. See how Cosmo makes data-driven scaling effortless.

GraphQL is Finally Boring.

The reports of GraphQL’s death have been greatly exaggerated. Let’s look beyond trends, instead, at how a mature, reliable GraphQL is making organizations better.

Introducing astjson: Transform and Merge JSON Objects with Unmatched Speed in Go

Transitioning from Monolithic to Federated Architecture with GraphQL

Explore the shift from monoliths to Federated GraphQL. Learn how modular APIs boost scalability, dev speed, and flexibility—plus tips for a smooth migration.

How to analyze the usage of your GraphQL Schema

Learn how to analyze GraphQL schema usage to optimize APIs, prevent breaking changes, and improve observability with federation-aware analytics.

How to analyze the usage of your GraphQL Schema

Get deep insights into GraphQL schema usage. Identify unused fields, monitor client behavior, and enable safe, data-driven schema evolution.

A Open Source Schema Registry with Schema Checks for Federated GraphQL

With Cosmo, it’s easier than ever to manage your federated GraphQL schemas and prevent composition errors and breaking changes before they reach production.

An Introduction to Cosmo Router — Blazingly Fast Open-Source Federation V1/V2 Gateway

Apollo Router’s Elastic license preventing adoption? Want to go even faster? This open-source Federation gateway has got you covered.

Dataloader 3.0: A new algorithm to solve the N+1 Problem

Introducing a new algorithm to solve GraphQL’s N+1 problem. Learn how breadth-first data loading cuts complexity and boosts performance up to 5x.

Refactoring Monoliths to Microservices with the BFF and Strangler Patterns

Refactor monoliths to microservices with the BFF & Strangler patterns. Avoid adapter hell and shield frontends using WunderGraphs unified BFF layer.

5 Best Practices for Backends-for-Frontends

Best practices to follow when implementing the BFF pattern: do’s and don’ts

7 Key Lessons I Learned While Building Backends-for-Frontends

Crucial takeaways from building production-ready BFFs that every developer should know.

Return JSON from OpenAI to build AI enhanced APIs

Build AI-enhanced APIs with OpenAI that return structured JSON. Automate schema validation and OpenAPI docs using the WunderGraph Agent SDK.

Preventing prompt injections with Honeypot functions

Learn how Honeypot functions help prevent prompt injection attacks in AI-powered APIs built with OpenAI.

Beyond Functions: Seamlessly build AI enhanced APIs with OpenAI

Create structured, AI-powered APIs and Agents that integrate with REST, GraphQL, SOAP, and databases—securely, scalably, and without prompt injection risks.

TypeSafe Testing in Backends-for-Frontends

Struggling with integration, unit & E2E tests in your BFF? WunderGraph’s type-safe testing & mocking makes API testing easier.

Fixing the Backends-for-frontends pattern with Build-time GraphQL

Fix the BFF pattern’s limitations using build-time GraphQL. WunderGraph delivers secure, fast, type-safe APIs—without runtime GraphQL overhead

The Easiest Way to Bake Auth Into Your Backend-for-Frontend with Clerk and WunderGraph

A true match made in heaven, learn how to implement authentication in your BFF architecture in minutes!.

Here's the Universal API ORM for REST, SOAP and GraphQL and more

Call REST, GraphQL, SOAP, and SQL as if they were one API. The WunderGraph ORM gives you type-safe access to any source—without relying on SDKs.

GraphQL doesn't solve under & overfetching, Relay & WunderGraph does

Dodging the Vercel Tax

Get Vercel-level DX with Postgres, Redis & Blob—without the markup. Use WunderGraph, an open-source alternative to Vercel Storage with no vendor lock-in.

Do you even test?

Easily write end-to-end tests for your API Gateway with mocks. Learn how WunderGraph makes testing integrations faster, safer, and more maintainable.

Why you should Relay give GraphQL another look

Explore how Relay and WunderGraph enable secure, fast, type-safe GraphQL apps with SSR, persisted queries, and no runtime API exposure.

5 Best Backend-for-Frontend Tools You Should Be Using

Discover 5 powerful Backend-for-Frontend tools—like WunderGraph, Istio, and AWS—to simplify API integration, auth, observability, and scaling.

The Backend-for-Frontend pattern using NextJS A Step-by-Step Guide

Start with BFFs, scale to GraphQL Federation. Build secure, type-safe APIs in Next.js with WunderGraph as your Backend-for-Frontend layer.

Is GraphQL dying? 2023 Trend Analysis of REST, GraphQL, OpenAPI, SOAP, gRPC and tRPC

Integration Testing for GraphQL APIs, type-safe, run locally and in CI

Write fast, type-safe integration tests for GraphQL and REST APIs using WunderGraph. Run tests locally or in CI with built-in support for federation and auth.

Embedding SQL into GraphQL without sacrificing type safety

Learn how to embed SQL in GraphQL without losing type safety. This guide shows how to rewrite operations at the gateway level using AST transformations.

10 GraphQL Developer Tools I Use To Make Building APIs Easier

Discover 10 GraphQL tools that streamline API development—from schema visualization to testing and performance. Build faster, debug better, and ship with ease.

How to be the worst engineer on your team?

To what extent should we compare ourselves to others? How can we channel differences positively?

TypeScript First API Development: Never Write OpenAPI Specifications Again

Skip the manual OpenAPI work. With WunderGraph’s TypeScript-first approach, generate OpenAPI specs directly from your code—no annotations, no boilerplate.

Serverless CI with Podman, Firecracker, fly.io Machines, and temporal.io

This is the story of how we built the CI/CD system for WunderGraph Cloud. 13s builds on top of giants like fly.io Machines, Podman, and temporal.io.

TypeScript Made Easy

Learn TypeScript the fun way—build your first full stack Todo App with Next.js, Prisma & WunderGraph. End-to-end typesafety, zero boilerplate.

The most important lesson I've had to learn as a technical founder

If you want to build a business, you have to stop being obsessed with technology and start to focus on the customer and their problems.

Building internal tools with WunderGraph and Interval

A guide that shows you how to build internal tools using WunderGraph and Interval.

GraphQL's @defer and @stream Directives are overkill

The GraphQL directives @defer and @stream are a great way to incrementally load data, but they are a complex solution that can be solved in a much simpler way.

A comprehensive Guide to WunderGraph and WunderGraph Cloud

A comprehensive guide to WunderGraph, the API Gateway that turns GraphQL into RPC on the fly, with a focus on its TypeScript Operations

Isomorphic TypeScript APIs: End-to-end type-safety between client & server

Blur the lines between frontend and backend with isomorphic TypeScript APIs. Get instant type-safe feedback for faster full-stack development—no codegen needed.

Build a Serverless Live Chat App with Next.js, Fauna & WunderGraph

Learn to build a real-time serverless chat app using WunderGraph’s Live Queries, Next.js, and Fauna—no WebSockets needed, just scalable GraphQL.

Data Fetching with Next.js 13’s Bleeding-Edge Features

Explore data fetching with Next.js 13 using Streaming and Suspense. Build a record catalog app with GraphQL and WunderGraph for seamless end-to-end typesafety.

How to Use ChatGPT as an Educational Chatbot in a Next.js Frontend

Can you use OpenAI’s GPT-3.5 on your website as a chat assistant? You bet. Here’s how to get it done with an Express server, WunderGraph as a BFF, and GraphQL.

The simplicity of tRPC with the power of GraphQL

tRPC is a new alternative to GraphQL that promises to be a lot simpler, but at what cost? What tradeoffs does it make? Let's find out!

How to Compose and Integrate APIs Together as if You Were Using NPM for APIs

Bring React-style composability to APIs, microservices & databases using GraphQL, WunderGraph, and the BFF/API Gateway pattern.

How to Build a GraphQL eCommerce App from Scratch

Setting JAMstack to easy mode with WunderGraph, Next.js, Strapi, and Snipcart

Quirks of GraphQL Subscriptions: SSE, WebSockets, Hasura, Apollo Federation / Supergraph

GraphQL is not Terraform

GraphQL is used in many different ways. In this post, I'd like to show why GraphQL is not ideal as a configuration language.

Build flexible GraphQL APIs by treating the Schema like a Database

By treating your GraphQL API like a Database, you're able to build flexible and easy to maintain APIs, with the additional benefit of making them easy to audit.

4 ways to stitch, integrate, compose & federate multiple GraphQL APIs

Combining multiple GraphQL APIs can be a challenge. Learn about four different methods to solve the problem and the tradeoffs of each approach.

How to improve your markdown-based docs with automatic tagging

Help your readers to better understand your markdown-based docs by automatically tagging the content with cross-references to other parts of your documentation.

Stop Building Your MVP Before You Figure Out These 7 Founder Lessons

Most technical founders overbuild and underplan. Learn 7 lessons to avoid wasted effort, from user acquisition to sales strategy, before coding your MVP.

How WunderGraph helps Developers to compose & integrate APIs

Discover how WunderGraph streamlines API composition and integration with Gateway-Less API Management that fits modern developer workflows.

Open Source GraphQL CDN / Edge Cache with Cloudflare, Fastly, and Fly.io

WunderGraph's open-source approach to GraphQL CDN and edge caching works with Cloudflare, Fastly, Fly.io, and more—without vendor lock-in or complexity.

NextJS / React SSR: 21 Universal Data Fetching Patterns & Best Practices

21 Universal Data Fetching Patterns & Best Practices for NextJS / React SSR

GraphQL Subscriptions: Why we use SSE/Fetch over Websockets

WebSockets should be deprecated for GraphQL Subscriptions. Instead, we're proposing to use Server Sent Events.

API Design Best Practices for long-running Operations: GraphQL vs REST

Discover how to design asynchronous APIs for long-running operations using REST or GraphQL. Learn trade-offs, patterns, and best practices for robust API workflows.

Thunk-based Resolvers: Building a Flexible GraphQL API Gateway

Learn how thunk-based resolvers enable modular, schema-free GraphQL Gateways. Boost flexibility, performance, and support for REST, federation, and subscriptions.

How to market your product as a Technical Founder

How WunderGraph’s founders grew their user base through hands-on marketing—from cold outreach to content and community—in just 6 months.

WunderHub - The Package Manager for APIs Public Beta

Try WunderHub, the first API package manager. Share, discover & integrate APIs faster. Now in public beta — feedback welcome!

What every GraphQL user should know about HTTP and REST

Stop choosing between GraphQL and REST. Combine their strengths to build more flexible, powerful APIs with the best of both worlds.

How automating API Integrations benefits your business

Automate API integrations with WunderGraph to save developer time, cut costs, and boost efficiency across your software ecosystem.

Join data across APIs: GraphQL, REST, PostgreSQL, MySQL and more

Learn how to join data across GraphQL, REST, PostgreSQL, MySQL, and more using a single GraphQL operation—no stitching or federation required.

Namespacing for GraphQL: Conflict-Free merging of any number of APIs

WunderGraph introduces the concept of Namespacing to GraphQL, allowing you to merge any number of APIs without naming conflicts.

Instant Realtime APIs using PostgreSQL, MySQL, SQLite, SQLServer and Planetscale

WunderGraph now supports PostgreSQL, MySQL, SQLite, SQLServer and Planetscale as DataSources to generate a production-ready Realtime API in Minutes

API Management does too little, Backend as a Service does too much

Explore the limitations of API Management and Backend as a Service, and how WunderGraph bridges the gap to offer extensibility, type safety, and zero vendor lock-in.

GraphQL file uploads - evaluating the 5 most common approaches

Explore 5 ways to handle file uploads in GraphQL—from base64 to S3 and WunderGraph’s TokenHandler Pattern. See which approach balances speed and security..

GraphQL in production - Analyzing public GraphQL APIs #1: Twitch.tv

Explore how Twitch runs GraphQL in production. From batching to APQ, HTTP quirks, and performance trade-offs—learn what works and what to avoid at scale.

Build JSON APIs with JSON-Schema by writing GraphQL Operations against any DataSource like REST, GraphQL, Apollo Federation, PostgreSQL and MySQL

Learn how to build JSON APIs with JSON Schema validation by writing GraphQL Operations against any DataSource like GraphQL, REST, PostgreSQL or MySQL

The Fusion of GraphQL, REST, JSON-Schema and HTTP2

REST vs. GraphQL is the wrong question. Instead, combine the two! Making GraphQL more RESTful is the better solution than choosing one technology exclusively.

Versionless APIs - Making APIs backwards compatible FOREVER to enable businesses to collaborate

A visionary approach to solving API versioning problems one and for all, keeping APIs backwards compatible forever.

The complete GraphQL Security Guide: Fixing the 13 most common GraphQL Vulnerabilities to make your API production ready

A description of the 13 most common GraphQL vulnerabilities and how to mitigate them.

Solving the Double (Quintuple) Declaration Problem in GraphQL Apps

Stop repeating yourself across your stack. Learn how to eliminate redundant declarations in GraphQL apps using codegen, JSON Schema, and WunderGraph.

Authentication for NextJS with GraphQL & REST APIs and SSR (Server Side Rendering)

A discussion on NextJS, GraphQL and Authentication and how to get it right with SSR (Server Side Rendering)

Where in the HypeCycle is GraphQL in 2021? Analyzing public data from Google Trends, StackOverflow, GitHub and HackerNews

A review of public data from Google Trends, StackOverflow, GitHub and HackerNews to better understand if GraphQL is still a trending technology.

Apollo GraphQL Federation with Subscriptions - production grade and highly scalable

Learn how WunderGraph lets you get the most out of Apollo Federation, being the only provider with a Gateway that supports Subscriptions for SubGraphs.

Polyglot persistence for PostgreSQL & MySQL using GraphQL & TypeScript

Storing data in either PostgreSQL or MySQL using the exact same interface, a GraphQL API

What if we treat GraphQL Queries as the API definition?

Explore a powerful pattern where GraphQL operations define your API, enabling type-safe clients, input validation, and secure auth—all from your queries.

The most powerful GraphQL Client for the web in just 2kb

WunderGraph offers the most powerful GraphQL client for the web in just 2.5kb. Outperforms Apollo & urql in speed, DX, and security—without the bloat.

Why you need a Package Manager for APIs

Packager Managers are Common for storing and sharing code. This post describes how we can apply the same pattern to APIs as well.

Generated GraphQL APIs: Tight Coupling as a Service

A discussion on the problems related to generating GraphQL APIs from a Database Schema, like tight coupling the client to the server.

Why not use GraphQL?

Analyzing common misconceptions on the discussion around GraphQL vs. REST.

GraphQL is not meant to be exposed over the internet

A discussion about the problems with using GraphQL over HTTP POST requests and how to improve the situation with a JSON RPC facade.

The case against normalized caching in GraphQL

A discussion on the topic of normalized caching in GraphQL Clients, why it's inefficient and how better solutions could look like