高度なGraphQLフェデレーション: 分散型スーパーグラフの構築

                    ┌─────────────────────────────────┐
Client ────────────▶│        Apollo Router (Gateway)   │
                    └─────┬─────────┬────────┬─────────┘
                          │         │        │
                    ┌─────▼──┐ ┌────▼──┐ ┌──▼──────┐
                    │ Users  │ │Orders │ │ Products │
                    │Subgraph│ │Subgraph│ │ Subgraph │
                    └────────┘ └────────┘ └──────────┘
                          │         │        │
                    Postgres    MongoDB    Postgres

query GetOrderWithDetails {
  order(id: "ord_123") {
    id
    total
    user {
      name
      email
    }
    items {
      product {
        name
        price
      }
      quantity
    }
  }
}

# users-subgraph/schema.graphql
extend schema
  @link(url: "https://specs.apollo.dev/federation/v2.3", import: ["@key", "@shareable"])

type User @key(fields: "id") {
  id: ID!
  name: String!
  email: String!
  createdAt: String!
}

type Query {
  user(id: ID!): User
  me: User
}

# orders-subgraph/schema.graphql
extend schema
  @link(url: "https://specs.apollo.dev/federation/v2.3", import: ["@key", "@external", "@requires"])

# Reference the User entity defined in the Users subgraph
type User @key(fields: "id") {
  id: ID!
  orders: [Order!]!
}

type Order @key(fields: "id") {
  id: ID!
  total: Float!
  status: OrderStatus!
  userId: ID!
  user: User!
  items: [OrderItem!]!
}

enum OrderStatus { PENDING, FULFILLED, CANCELLED }

type OrderItem {
  productId: ID!
  quantity: Int!
  unitPrice: Float!
}

type Query {
  order(id: ID!): Order
  orders(userId: ID!): [Order!]!
}

// users-subgraph/resolvers.ts
import { UserService } from "./services/UserService";

const resolvers = {
  User: {
    // Called by the gateway with the entity "representation" (partial object containing @key fields)
    __resolveReference: async (reference: { id: string }, context: Context) => {
      return context.dataSources.userService.findById(reference.id);
    },
  },
  Query: {
    user: (_: unknown, { id }: { id: string }, context: Context) => {
      return context.dataSources.userService.findById(id);
    },
    me: (_: unknown, __: unknown, context: Context) => {
      return context.dataSources.userService.findById(context.userId);
    },
  },
};

import DataLoader from "dataloader";

// Create a DataLoader per request (in context factory)
export function createUserLoader(db: Database): DataLoader<string, User> {
  return new DataLoader(
    async (userIds: readonly string[]) => {
      // Single DB query fetches all users at once
      const users = await db.query(
        "SELECT * FROM users WHERE id = ANY($1)",
        [userIds]
      );
      
      // DataLoader requires results in the same order as input keys
      const userMap = new Map(users.map((u) => [u.id, u]));
      return userIds.map((id) => userMap.get(id) ?? new Error(`User ${id} not found`));
    },
    { cache: true }   // cache within request — same user requested twice = one DB hit
  );
}

// In context factory:
const context = {
  loaders: { user: createUserLoader(db) }
};

// In resolver:
const resolvers = {
  User: {
    __resolveReference: async (reference: { id: string }, context: Context) => {
      return context.loaders.user.load(reference.id);
    },
  },
};

# shipping-subgraph/schema.graphql
type User @key(fields: "id") {
  id: ID!
  address: String! @external       # owned by Users subgraph
  shippingZone: ShippingZone!      # computed from address by Shipping subgraph
    @requires(fields: "address")
}

const resolvers = {
  User: {
    __resolveReference: async (reference: { id: string; address: string }) => {
      // `address` is provided by the gateway from the Users subgraph
      return {
        id: reference.id,
        shippingZone: computeShippingZone(reference.address),
      };
    },
  },
};

# Install Rover
curl -sSL https://rover.apollo.dev/nix/latest | sh

# Check subgraph schema for Federation compatibility
rover subgraph check my-graph@production \
  --schema ./users-subgraph/schema.graphql \
  --name users

# Publish subgraph schema to Apollo Studio
rover subgraph publish my-graph@production \
  --schema ./users-subgraph/schema.graphql \
  --name users \
  --routing-url https://users.internal.example.com/graphql

# Compose supergraph schema locally (for CI validation)
rover supergraph compose --config ./supergraph.yaml > supergraph-schema.graphql

federation_version: =2.3.5
subgraphs:
  users:
    routing_url: https://users.internal.example.com/graphql
    schema:
      file: ./users-subgraph/schema.graphql
  orders:
    routing_url: https://orders.internal.example.com/graphql
    schema:
      file: ./orders-subgraph/schema.graphql
  products:
    routing_url: https://products.internal.example.com/graphql
    schema:
      file: ./products-subgraph/schema.graphql

type Product @key(fields: "id") @cacheControl(maxAge: 300) {
  id: ID!
  name: String! @cacheControl(maxAge: 3600)    # rarely changes
  price: Float! @cacheControl(maxAge: 60)       # changes more often
  stockCount: Int! @cacheControl(maxAge: 0)     # never cache
}

async function findProductById(id: string): Promise<Product> {
  const cached = await redis.get(`product:${id}`);
  if (cached) return JSON.parse(cached);
  
  const product = await db.products.findById(id);
  await redis.setex(`product:${id}`, 300, JSON.stringify(product)); // 5-min TTL
  return product;
}

# router.yaml
supergraph:
  path: /graphql

cors:
  origins:
    - https://app.example.com
  
headers:
  all:
    request:
      - propagate:
          matching: ^x-.*   # forward all x-* headers to subgraphs

traffic_shaping:
  all:
    deduplicate_variables: true
  router:
    timeout: 30s
  subgraphs:
    users:
      timeout: 5s
    orders:
      timeout: 10s

telemetry:
  exporters:
    tracing:
      otlp:
        endpoint: http://otel-collector:4317

docker run -p 4000:4000 \
  -v $(pwd)/supergraph-schema.graphql:/app/supergraph.graphql \
  -v $(pwd)/router.yaml:/app/router.yaml \
  ghcr.io/apollographql/router:v1.46.0 \
  --supergraph /app/supergraph.graphql \
  --config /app/router.yaml

curl -X POST http://localhost:4000/graphql \
  -H "Content-Type: application/json" \
  -d '{"query": "{ order(id: \"123\") { user { name } items { product { name } } } }"}' \
  -H "Apollo-Query-Plan-Experimental: true"