GraphQL, KOA e MongoDB: come creare una semplice API sfruttando la versatilità di GraphQL — seconda parte

Danilo Del Fio
Aug 26, 2019 · 4 min read

Questa è la seconda parte di una serie in cui cerchiamo di capire come creare delle API con GraphQL, koa ed utilizzando MongoDB per la persistenza dei nostri dati. Qui potere trovare la prima parte della serie (nella prima pate troverete come creare il server, installare le dipendenze, ecc…).

Mutation

Nella prima parte ho cercato di porre le basi per eseguire una query di “ricerca”, dove le nostre API ci restituivano la risorsa desiderata a partire dall’id della stessa. In questo articolo vorrei parlare di come creare una API che ci aiuti a creare una nuova risorsa o modificarne una con GraphQL (corrispondente ai metodi POST e PUT di REST).

Inseriamo un documento nel DB

Per poter aggiungere un documento nel nostro database, abbiamo la necessità di costruire un oggetto GraphQL in grado di interpretare ciò che viene inviato dal frontend (nel nostro caso l’interfaccia GraphiQL), ed eseguire la query con mongoose per eseguire la nostra insert.

Iniziamo, quindi, col creare il nostro oggetto, che sarà del tutto simile a quanto visto nel caso della query di selezione dell’articolo precedente, con alcuni cambiamenti.

const Mutation = new GraphQLObjectType({
name: 'Mutation'
...
})

Come possiamo vedere il nostro oggetto sarà sempre di tipo GraphQLObjectType, ma la sua proprietà name, sarà di tipo Mutation.

L’oggetto in questione contiene l’attributo fields che mapperà tutte le risorse di tipo Mutation al suo interno.

Chiamiamo la nostra risorsa, ancora una volta, project. Essa avrà, al suo interno, due attributi:

  • args
  • resolve()

Come è facile intuire, args conterrà i nomi ed i tipi di tutti gli attributi che compongono la mia risorsa “project” (quella che voglio persistere). Avremo quindi:

...
args: {
name: { type: GraphQLString },
last_update: { type: GraphQLString },
owner: { type: GraphQLString },
type: { type: GraphQLString }
},
...

Per semplicità ho definito tutti gli attributi di tipo GraphQLString, ma, come è facile intuire, ci sono diversi tipi definibili per un oggetto GraphQL.

L’altro attributo, resolve(), ci permetterà di eseguire la query nel nostro database:

...
resolve(parent, args) {
const project = new Project();
project.name = args.name;
project.last_update = args.last_update;
project.owner = args.owner;
project.type = args.type;
return project.save();
}
...

A questo punto abbiamo concluso la nostra prima Mutation, che avrà la forma:

const { GraphQLObjectType, GraphQLString } = require('graphql');
const projectGraphQLType = require('./projectType');
const Project = require('./../models/projects');
const Mutation = new GraphQLObjectType({
name: 'Mutation',
fields: {
project: {
type: projectGraphQLType,
args: {
name: { type: GraphQLString },
last_update: { type: GraphQLString },
owner: { type: GraphQLString },
type: { type: GraphQLString }
},
resolve(parent, args) {
const project = new Project();
project.name = args.name;
project.last_update = args.last_update;
project.owner = args.owner;
project.type = args.type
return project.save();
}
}
}
});
module.exports = Mutation;

Per poterla utilizzare, bisogna configurare la Mutation appena creata all’interno del file schema.js:

module.exports = new GraphQLSchema({
query: RootQuery,
mutation: Mutations
});

Test

Ora possiamo testare la nostra prima Mutation attraverso l’interfaccia GraphiQL (fare riferimento all’articolo precedente per tirar su il server e importare tutte le dipendenze).

Puntando il nostro browser su http://localhost:9000/api, la prima cosa che possiamo vedere è che sulla destra abbiamo la documentazione delle nostre API generata in modo automatico, che ci permette di vedere i vari Tipi definiti nel nostro server GraphQL. Cliccando, quindi, su “< Docs” , in alto a destra vediamo :

Si vedono chiaramente le due query create negli esempi presenti in questo articolo ed in quello procedente, con la loro tipologia.

Ci concentreremo, in questo momento, sulla query di tipo “Mutation”.

Cliccando, quindi, su “Mutation”, possiamo vedere come deve essere fatta una risorsa che possiamo inviare al server GraphQL.

La risorsa, si dovrà chiamare project ed avere gli attributi specificati (name, last_update, owner, type).

Cerchiamo di persistere un nuovo progetto:

mutation {
project(name: "Facebook", last_update: "17/08/2019", owner: "Mark Zucherberg", type: "social") {
name
last_update
owner
type
}
}

Eseguendo la query, otterremo:

Come possiamo vedere, il server ci ha risposto con l’oggetto appena inviato. Andiamo a guardare ora il nostro database per vedere se è stato effettivamente persistito.

In effetti il nuovo progetto è stato salvato nella nostra collection koa-graphql.

Codice dell’esempio

Potete trovare tutto il codice dell’esempio nel seguente GitHub repo.

Conclusioni

Con questa serie di articoli volevo presentare le basi su come integrare koa, graphQL e mongoDB, per cercare di far capire che GraphQL può essere un valido sostituto di REST per l’implementazione delle API.

More From Medium

Also tagged GraphQL

Top on Medium

Welcome to a place where words matter. On Medium, smart voices and original ideas take center stage - with no ads in sight. Watch
Follow all the topics you care about, and we’ll deliver the best stories for you to your homepage and inbox. Explore
Get unlimited access to the best stories on Medium — and support writers while you’re at it. Just $5/month. Upgrade