엔터티 참조와 @key 지시문

In federation, a single type like Product can be owned and extended by several subgraphs. The mechanism that lets them agree on the same object is the entity.

An entity is a type with a @key directive. The key names the field(s) that uniquely identify an instance across subgraphs, like a primary key in a database.

The subgraph that defines a type's core fields is its owner. It is responsible for fetching a full entity given just its key, so the gateway can stitch data together.

Another subgraph can add fields to the same entity. It declares the type with the matching @key and marks borrowed fields as external context.

When the gateway needs an entity from a subgraph, it calls a special reference resolver, passing only the key fields. The subgraph returns the matching object.

Spring for GraphQL Federation provides @EntityMapping to implement the reference resolver. The key fields arrive as arguments.

Enable federation by adding the Apollo federation JVM support, which generates the _entities and _service fields the gateway requires.

An entity can be identified by multiple fields. List them space-separated in the @key, useful when no single field is unique.

A type can declare several @key directives, letting different subgraphs reference it by whichever identifier they hold.

The gateway queries the owning subgraph, then sends the entity's keys to other subgraphs via _entities to fetch their extra fields, merging everything into one response.

Design entities carefully:

• Pick stable, unique key fields
• One subgraph owns the core fields
• Keep reference resolvers fast (consider DataLoaders)
• Use compound keys only when necessary

You learned federated entities:

• An entity is a type with a @key
• One subgraph owns it; others extend it
• Reference resolvers (@EntityMapping) fetch by key
• Compound and multiple keys handle complex identity

Entities and @key are how federation stitches a unified graph from many subgraphs.