Creare un server GraphQL con Apollo, MariaDB e Squelize

In questo articolo vedremo come creare un server GraphQL con Apollo Server e MariaDB.

Useremo anche Sequelize per la connessione al db.

Il db già esiste, e la tabella che interrogheremo si chiama persone:

• id
• email

Cominciamo con l'installazione tramite npm:

npm install apollo-server graphql sequelize @sequelize/mariadb mysql2

A questo punto creiamo un file db.js:

import {Sequelize} from 'sequelize';

const sequelize = new Sequelize({
    dialect: 'mariadb',
    database: 'test',
    username: 'root',
    password: '9211',
    host: 'localhost',
    port: 3306,
    logging: false,
});

export const connectDB = async () => {
    try {
        await sequelize.authenticate();
        console.log('Connessione a MariaDB stabilita con successo.');
        return sequelize;
    } catch (error) {
        console.error('Errore durante la connessione a MariaDB:', error);
        process.exit(1);
    }
};

export default sequelize;

Poi il file schema.js:

import {gql} from 'apollo-server';

const typeDefs = gql`
  # Il tipo corrisponde alla tua tabella 'persone'
  type Persona {
    id: Int!
    email: String!
  }

  type Query {
    # Query per ottenere una singola persona tramite ID
    persona(id: Int!): Persona
    # Query per ottenere tutte le persone
    persone: [Persona!]!
  }
  
  type Mutation {
    # Mutazione per aggiungere una nuova persona
    aggiungiPersona(email: String!): Persona
  }
`;

export default typeDefs;

Poi il resolvers.js:

import {QueryTypes} from 'sequelize';

const resolvers = {
    Query: {
        persona: async (parent, {id}, {db}) => {
            const [results] = await db.query(
                `SELECT id, email
                 FROM persone
                 WHERE id = :id`,
                {
                    replacements: {id},
                    type: QueryTypes.SELECT
                }
            );
            return results;
        },

        persone: async (parent, args, {db}) => {
            const results = await db.query(
                `SELECT id, email
                 FROM persone`,
                {
                    type: QueryTypes.SELECT
                }
            );
            return results;
        },
    },

    Mutation: {
        aggiungiPersona: async (parent, {email}, {db}) => {
            const [insertResult, metadata] = await db.query(
                `INSERT INTO persone (email)
                 VALUES (:email)`,
                {
                    replacements: {email},
                    type: QueryTypes.INSERT,
                }
            );

            const newId = metadata;

            const [newPersona] = await db.query(
                `SELECT id, email
                 FROM persone
                 WHERE id = :newId`,
                {
                    replacements: {newId},
                    type: QueryTypes.SELECT
                }
            );

            return newPersona;
        },
    }
};

export default resolvers;

Infine avviamo il server (index.js):

import {ApolloServer} from 'apollo-server';
import typeDefs from './schema.js';
import resolvers from './resolvers.js';
import sequelize, {connectDB} from './db.js';

await connectDB();

const server = new ApolloServer({
    typeDefs,
    resolvers,
    context: ({req}) => ({
        db: sequelize,
    }),
});

server.listen().then(({url}) => {
    console.log(`Server GraphQL pronto su ${url}`);
});

Qui sotto due comandi curl per visualizzare le persone e crearle:

$ curl -X POST   http://localhost:4000/ -H 'Content-Type: application/json' -d '{
    "query": "mutation AddPersona($email: String!) { aggiungiPersona(email: $email) { id email } }",
    "variables": {
      "email": "test.curl@example.com"
    }
  }'


$ curl -X POST   http://localhost:4000/ -H 'Content-Type: application/json' -d '{
    "query": "query GetAllPersone { persone { id email } }"
  }'

Enjoy!