Creare API con GraphQL e Node.JS

Link copiato negli appunti

Negli ultimi anni GraphQL si è affermato come una delle tecnologie più potenti per costruire API moderne. Creato da Facebook, GraphQL offre un'alternativa flessibile e altamente personalizzabile al tradizionale approccio REST, permettendo ai client di specificare esattamente i dati di cui hanno bisogno. In questa guida capiremo come utilizzare GraphQL per creare un'API con Node.JS.

Cos'è GraphQL

GraphQL è un linguaggio di query per le API e un runtime per eseguire tali query sui tuoi dati. Offre diversi vantaggi rispetto alle API REST:

richieste specifiche
Un singolo endpoint
Evoluzione senza interruzioni

Esempio di una query GraphQL:

query { user(id: "1") { id name posts { title content } } }

Risultato della query:

{
  "data": {
    "user": {
      "id": "1",
      "name": "Alice",
      "posts": [
        {
          "title": "Il mio primo post",
          "content": "Benvenuti nel mio blog!"
        }
      ]
    }
  }
}

Prerequisiti

Per seguire questa guida, è necessario avere:

Node.js
npm Yarn
Familiarità di base con JavaScript

Configurare il progetto

Creiamo un nuovo progetto Node.js per iniziare:

mkdir graphql-api
cd graphql-api
npm init -y

Installiamo poi le dipendenze necessarie:

npm install express graphql express-graphql

Queste librerie includono:

Express
GraphQL
Express-graphql

Creare un server GraphQL

Iniziamo con un semplice server GraphQL. Crea un file server.js e aggiungi il seguente codice:

const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { buildSchema } = require('graphql');

// Definizione dello schema GraphQL
const schema = buildSchema(`
  type Query {
    hello: String
  }
`);
// Definizione del resolver per le query
const root = {
  hello: () => {
    return 'Ciao, GraphQL!';
  },
};

// Configurazione del server Express con GraphQL
const app = express();
app.use('/graphql', graphqlHTTP({
  schema: schema,
  rootValue: root,
  graphiql: true, // Interfaccia web per testare le query
}));
// Avvio del server
app.listen(4000, () => {
  console.log('Server GraphQL avviato su http://localhost:4000/graphql');
});

Avviamo quindi il server con il comando:

node server.js

Accediamo infine a http://localhost:4000/graphql per testare l'API GraphQL usando l'interfaccia GraphiQL.

Estendere lo schema

Ora rendiamo lo schema più complesso aggiungendo nuovi tipi e campi.

Aggiungere un tipo personalizzato

Aggiorniamo lo schema per includere un tipo User e una query per ottenere un utente per ID:

const schema = buildSchema(`
  type User {
    id: ID
    name: String
    age: Int
  }

  type Query {
    user(id: ID!): User
  }
`);
const root = {
  user: ({ id }) => {
    const users = [
      { id: '1', name: 'Alice', age: 25 },
      { id: '2', name: 'Bob', age: 30 },
    ];
    return users.find(user => user.id === id);
  },
};

Rilanciamo il server e proviamo una query come questa:

query {
  user(id: "1") {
    name
    age
  }
}

Aggiungere mutazioni

Oltre a leggere dati, GraphQL supporta mutazioni per modificare o aggiungere dati. Estendiamo lo schema per aggiungere una mutazione che crea un nuovo utente. Aggiorniamo per questa ragione lo schema e i resolver:

let users = [
  { id: '1', name: 'Alice', age: 25 },
  { id: '2', name: 'Bob', age: 30 },
];

const { buildSchema } = require('graphql');
const schema = buildSchema(`
  type User {
    id: ID
    name: String
    age: Int
  }

  type Query {
    user(id: ID!): User
    users: [User]
  }
  type Mutation {
    createUser(name: String!, age: Int!): User
  }
`);

const root = {
  user: ({ id }) => users.find(user => user.id === id),
  users: () => users,
  createUser: ({ name, age }) => {
    const newUser = { id: String(users.length + 1), name, age };
    users.push(newUser);
    return newUser;
  },
};

Ora possiamo inviare una mutazione per creare un utente:

mutation {
  createUser(name: "Charlie", age: 35) {
    id
    name
  }
}

Integrazione con un Database

Per rendere l'API più robusta, possiamo integrare un database. Useremo MongoDB con Mongoose.

Installare Mongoose

npm install mongoose

Configuriamo Mongoose in server.js

const mongoose = require('mongoose');
// Connessione a MongoDB
mongoose.connect('mongodb://localhost:27017/graphql-api', {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

// Definizione del modello User
const UserModel = mongoose.model('User', new mongoose.Schema({
  name: String,
  age: Number,
}));
// Definizione dei resolver
const root = {
  user: async ({ id }) => await UserModel.findById(id),
  users: async () => await UserModel.find(),
  createUser: async ({ name, age }) => {
    const user = new UserModel({ name, age });
    await user.save();
    return user;
  },
};

Ora i dati sono persistenti e memorizzati nel database MongoDB.

Protezione e Caching

Validazione
Rate Limiting
Autenticazione jsonwebtoken

Per il Caching usiamo infine strumenti come Dataloader per ottimizzare le query e ridurre le chiamate ripetitive al database.

Conclusione

In questa guida, abbiamo studiato come creare un'API GraphQL con Node.js. Partendo da uno schema semplice abbiamo aggiunto tipi personalizzati, mutazioni e persistenza con MongoDB. Con GraphQL, possiamo offrire API flessibili e scalabili che soddisfano le esigenze moderne dei client. Prossimi passi:

Integrare un sistema di autenticazione.
Implementare un meccanismo di caching.
Creare una documentazione per lo schema GraphQL.

GraphQL è uno strumento potente che può trasformare il modo in cui costruiamo e consumiamo API. Sperimenta con le sue funzionalità e scopri come può migliorare i tuoi progetti!

Indice lezioni