Développer une API GraphQL performante avec Node.js, TypeScript et Apollo Server

développer une API GraphQL performante avec Node.js, TypeScript et Apollo Server

Vous êtes CTO ou lead technique d’une startup/PME et vous souhaitez adopter GraphQL pour gagner en flexibilité et performance ? Ce guide détaille la création d’une API GraphQL de A à Z, avec Node.js, TypeScript et Apollo Server, tout en intégrant Prisma pour interagir efficacement avec PostgreSQL.

1. configuration et initialisation du projet

1. Créez le dossier et initialisez npm :

   mkdir graphql-saas && cd graphql-saas
   npm init -y

2. Installez les dépendances :

   npm install apollo-server graphql reflect-metadata
   npm install -D typescript ts-node @types/node

3. Générez le tsconfig.json :

   npx tsc --init --rootDir src --outDir dist --strict

4. Structurez :

   src/
    ├─ schema/
    ├─ resolvers/
    ├─ db.ts
    └─ index.ts

2. définition du schéma GraphQL

Dans src/schema/typeDefs.ts :

import { gql } from 'apollo-server';

export const typeDefs = gql`
  type User {
    id: ID!
    email: String!
    name: String
  }

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

  type Mutation {
    createUser(email: String!, name: String): User!
  }
`;

3. implémentation des résolveurs et connexion à PostgreSQL

On utilise Prisma comme ORM pour bénéficier de migrations et d’une API type-safe.

• Initialisez Prisma :

  npx prisma init --datasource-provider postgresql

• Définissez le modèle dans prisma/schema.prisma :

model User {
  id    Int    @id @default(autoincrement())
  email String @unique
  name  String?
}

• Exécutez la migration :

  npx prisma migrate dev --name init

Dans src/db.ts :

import { PrismaClient } from '@prisma/client';
export const prisma = new PrismaClient();

Dans src/resolvers/index.ts :

import { prisma } from '../db';

export const resolvers = {
  Query: {
    users: () => prisma.user.findMany(),
    user: (_: any, args: { id: number }) => prisma.user.findUnique({ where: { id: args.id } }),
  },
  Mutation: {
    createUser: (_: any, args: { email: string; name?: string }) =>
      prisma.user.create({ data: args }),
  },
};

4. lancement de l’API Apollo Server

Dans src/index.ts :

import 'reflect-metadata';
import { ApolloServer } from 'apollo-server';
import { typeDefs } from './schema/typeDefs';
import { resolvers } from './resolvers';

async function start() {
  const server = new ApolloServer({ typeDefs, resolvers });
  const { url } = await server.listen({ port: 4000 });
  console.log(`🚀 Serveur prêt sur ${url}`);
}

start().catch(console.error);

Lancez avec npx ts-node src/index.ts et rendez-vous sur http://localhost:4000 pour tester vos requêtes.

5. optimisation et bonnes pratiques

• Batching et caching avec DataLoader pour éviter le N+1.
• Validation et sécurité : utilisez graphql-shield ou Martin pour les permissions.
• Métriques et monitoring : exposez un endpoint Prometheus (Docker + /metrics).
• Tests automatisés : intégrez Jest et apollo-server-testing dans votre pipeline CI/CD.
• Déploiement : construisez une image Docker optimisée (multistage build) puis déployez sur Kubernetes ou Fargate.

6. suivi de la performance

Surveillez :

erreurs fréquentes

• Schema mismatch entre client et serveur : vérifiez les types.
• Connexion BD non gérée correctement : toujours fermer prisma.$disconnect().
• Problèmes CORS : configurez server.applyMiddleware({ cors: true }).

En suivant ces étapes, vous disposerez d’une API GraphQL robuste, scalable et facile à maintenir, parfaitement adaptée à un produit SaaS ou un module CRM/ERP. Pour un accompagnement personnalisé et gagner du temps, découvrez nos services SaaS ou contactez notre équipe via notre page de contact.

Prêt à accélérer votre développement GraphQL ? Parlons-en !