GET    /users          → list all users
POST   /users          → create user
GET    /users/42       → get user 42
PUT    /users/42       → replace user 42
PATCH  /users/42       → partial update user 42
DELETE /users/42       → delete user 42

GET    /users/42/posts → user's posts (nested resource)

GET /users/42

{
  "id": 42,
  "name": "Alice",
  "email": "alice@example.com",
  "role": "admin",
  "created_at": "2024-01-15",
  "preferences": { ... },
  "billing": { ... }
}

const express = require('express');
const router = express.Router();

router.get('/users/:id', async (req, res) => {
  const user = await db.users.findById(req.params.id);
  if (!user) return res.status(404).json({ error: 'User not found' });
  res.json(user);
});

router.post('/users', async (req, res) => {
  const user = await db.users.create(req.body);
  res.status(201).json(user);
});

type User {
  id: ID!
  name: String!
  email: String!
  posts: [Post!]!
}

type Post {
  id: ID!
  title: String!
  content: String
  author: User!
}

type Query {
  user(id: ID!): User
  users: [User!]!
  posts(authorId: ID): [Post!]!
}

type Mutation {
  createUser(name: String!, email: String!): User!
  updateUser(id: ID!, name: String): User!
  deleteUser(id: ID!): Boolean!
}

# Only fetch name and email — nothing else
query GetUser {
  user(id: "42") {
    name
    email
  }
}

# Fetch user AND their posts in one request (no under-fetching)
query UserWithPosts {
  user(id: "42") {
    name
    posts {
      title
      content
    }
  }
}

mutation CreateUser {
  createUser(name: "Bob", email: "bob@example.com") {
    id
    name
  }
}

const { ApolloServer, gql } = require('@apollo/server');

const typeDefs = gql`
  type User { id: ID!, name: String! }
  type Query { user(id: ID!): User }
`;

const resolvers = {
  Query: {
    user: async (_, { id }) => db.users.findById(id),
  },
};

const server = new ApolloServer({ typeDefs, resolvers });

query {
  posts {        # 1 query
    title
    author {     # N queries (one per post!)
      name
    }
  }
}

const DataLoader = require('dataloader');

const userLoader = new DataLoader(async (ids) => {
  const users = await db.users.findByIds(ids);
  return ids.map(id => users.find(u => u.id === id));
});

// Now all author fetches batch into one query
const resolvers = {
  Post: {
    author: (post) => userLoader.load(post.authorId)
  }
};