Comment construire une API GraphQL avec NestJS ?

Question

Accepted Answer

NestJS offre un support **GraphQL** de première classe via `@nestjs/graphql` (basé sur Apollo Server). Il propose une approche **code-first** (définir votre schéma avec des classes et décorateurs TypeScript, schéma auto-généré) — la façon idiomatique de NestJS — s'adaptant au modèle décorateur/injection de dépendances du framework.

## Configuration de GraphQL (approche code-first)

```ts
@Module({
  imports: [
    GraphQLModule.forRoot<ApolloDriverConfig>({
      driver: ApolloDriver,
      autoSchemaFile: "schema.gql",   // code-first: auto-generate the schema from classes
      playground: true,                // interactive query explorer in dev
    }),
  ],
})
export class AppModule {}
```

## Types d'objets (le schéma, définis avec des décorateurs)

```ts
@ObjectType()                        // a GraphQL type
export class User {
  @Field(() => ID) id: string;
  @Field() name: string;
  @Field() email: string;
  @Field(() => [Post]) posts: Post[];   // related type
}
```

En approche code-first, les classes décorées (`@ObjectType`, `@Field`) définissent le schéma — les types TypeScript génèrent automatiquement le schéma GraphQL, les maintenant synchronisés.

## Résolveurs (requêtes et mutations)

```ts
@Resolver(() => User)
export class UsersResolver {
  constructor(private usersService: UsersService) {}   // DI works as usual

@Query(() => [User])               // a query: returns a list of users
  users() {
    return this.usersService.findAll();
  }

@Query(() => User)
  user(@Args("id") id: string) {     // query with an argument
    return this.usersService.findOne(id);
  }

@Mutation(() => User)              // a mutation: creates a user
  createUser(@Args("input") input: CreateUserInput) {
    return this.usersService.create(input);
  }
}
```

Les résolveurs (comme les contrôleurs, mais pour GraphQL) définissent les gestionnaires `@Query` et `@Mutation`, en déléguant aux services via l'injection de dépendances — les mêmes patterns que les contrôleurs REST.

## Résolution des champs associés (éviter le problème N+1)

```ts
@ResolveField(() => [Post])         // resolve User.posts on demand
posts(@Parent() user: User) {
  return this.postsService.findByUser(user.id);
}
// ⚠️ for lists, this can cause N+1 queries → use DataLoader to BATCH them
```

`@ResolveField` résout les champs associés/imbriqués de manière paresseuse — mais pour les listes, cela risque le **problème de requête N+1**, résolu par le batching DataLoader.

## GraphQL vs REST : les compromis

```text
GraphQL: clients request EXACTLY the fields they need (no over/under-fetching),
         one endpoint, strongly typed, great for complex/nested data & varied clients
REST:    simpler, better HTTP caching, well-understood — fine for straightforward APIs
→ Choose based on needs, not hype. NestJS supports both equally well.
```

## Pourquoi c'est important

Le support GraphQL de première classe de NestJS est précieux car il apporte les avantages de GraphQL — les clients récupèrent exactement les données dont ils ont besoin (éliminant le sur-fetching et le sous-fetching), un endpoint unique fortement typé, et une excellente gestion des données complexes/imbriquées — dans le modèle familier et structuré de NestJS.
"]}