Mongoose: integrare Node.js e MongoDB

Spesso una tecnologia lato server crea un connubio solidissimo con un DBMS: se, ad esempio, PHP e MySQL hanno scritto la storia del web, l’epoca del NoSQL vede un forte affratellamento tra Node.js e MongoDB. Queste ultime tecnologie sono state anche poste alla base del cosiddetto stack MEAN (Mongo – Express – Angular.js – Node.js) che offre una struttura completa lato server con una flessibile controparte client.
Dopo aver parlato su queste pagine singolarmente di Node.js e MongoDB, in questo post presentiamo una libreria utilissima alla loro fusione che mette a disposizione un contesto di lavoro efficiente e produttivo: oggi parliamo di Mongoose.

Mongoose funziona in stile ORM: in pratica, forniamo uno schema di lavoro – detto Model – che riassume la struttura di una tipologia di dati da salvare in MongoDB e, successivamente, la usiamo per istanziare oggetti che saranno automaticamente dotati di metodi per svolgere le classiche operazioni CRUD. Tutti i dati così inseriti e trattati saranno immagazzinati in MongoDB ma in una maniera così comoda che la sua presenza passerà inosservata.

Iniziamo ad usare Mongoose

Per integrare Mongoose passiamo, come al solito, per npm, digitando nella nostra directory di lavoro:

$ npm init
$ npm install mongoose --save

Nel nostro esempio, avremo a disposizione un’istanza di MongoDB che sarà contattabile all’indirizzo localhost, alla porta 27017. Creeremo un database che chiameremo Geonotes in cui potremo registrare delle note geolocalizzate composte da titolo, testo, descrizione del luogo, date di creazione e modifica nonchè un ulteriore oggetto JSON in cui segneremo latitudine e longitudine del luogo in cui prendiamo l’appunto.
Creiamo il nostro Model per Mongoose in cui dettiamo lo schema che le note devono seguire e lo facciamo in un modulo Node.js:

var mongoose = require('mongoose');

mongoose.connect('mongodb://localhost/geonotes');

var Schema = mongoose.Schema;

var notesSchema = new Schema({
  title: String,
  text: String,
  place: String,
  position: {
    latitude: Number,
    longitude: Number
  },
  created: Date,
  updated: Date
});

var Geonote = mongoose.model('Geonotes', notesSchema);

module.exports = Geonote;

Salveremo il codice appena visto nel file geonote_module.js e lo utilizzeremo nei nostri programmi per Node.js. Essenzialmente, in esso, abbiamo richiesto l’utilizzo del modulo mongoose e poi ci siamo connessi alla nostra installazione di MongoDB. Creiamo un oggetto Schema che rappresenta la forma delle note: può contenere oggetti annidati e per ogni proprietà suggeriamo il tipo di dato che dovrà rappresentarla (per un approfondimento su quali sono i tipi di dato validi si può consultare la documentazione del progetto).

Inserimento dati

Per provare il Model che abbiamo preparato, vediamo un semplice programma Node.js in cui inseriamo tre note. Si faccia solo caso che al fine di provare lo script più volte nonchè di imparare un comando in più su Mongoose la creazione dei dati è preceduta dallo svuotamento della relativa Collection:

var Geonote = require('./geonote_module');

 Geonote.remove({}, function(err) {
            if (err) {
                console.log(err)
            } 
	    else {console.log('cancellazione eseguita')}
        }
    );

var note1 = new Geonote({
  title: 'Gita a Venaria',
  text: 'Ci siamo tanto divertiti bla bla bla....',
  place: 'Venaria',
  position: {latitude: 45.137058, longitude: 7.621327},
  created: new Date('2016-04-15'),
  updated: new Date('2016-04-15')
});

var note2 = new Geonote({
  title: 'Giornata a Ivrea',
  text: 'Siamo venuti per lavoro.....',
  place: 'Nostri uffici a Ivrea',
  position: {latitude: 45.459330, longitude: 7.872489},
  created: new Date('2016-03-09'),
  updated: new Date('2016-03-21')
});

var note3 = new Geonote({
  title: 'Festa di Luca',
  text: 'Riuscita molto bene! ... ',
  place: 'Casa di Luca',
  position: {latitude: 45.068557, longitude: 7.641706},
  created: new Date('2016-02-27'),
  updated: new Date('2016-02-28')
});

note1.save(function(err) {
  if (err) throw err;

  console.log('Salvataggio completato');
});

note2.save(function(err) {
  if (err) throw err;

  console.log('Salvataggio completato');
});

note3.save(function(err) {
  if (err) throw err;

  console.log('Salvataggio completato');
});

Geonote rappresenta il modulo che abbiamo creato prima e con esso svolgiamo subito la cancellazione degli oggetti salvati nella collection: al posto di {} si potrà usare un criterio più specifico per cancellare un subset dei documenti inseriti.

Per quanto riguarda gli inserimenti, creeremo degli oggetti secondo la struttura dettata dal Model e, per il loro immagazzinamento definitivo, invocheremo su di essi il metodo save.

Qualche query

Anche nello svolgimento di query Mongoose segue i classici comandi di MongoDB.

Questa query, ad esempio, recupera le note che vedono “Venaria” come luogo di registrazione:

Geonote.find({place: 'Venaria'}).exec(function(err, notes) {
  if (err) throw err;
  console.log(notes);
});

mentre per recuperare tutti i documenti creati dopo il giorno 8 marzo 2016:

Geonote.find({}).where('created').gt(new Date('2016-03-08')).exec(function(err, notes) {
  if (err) throw err;

  // show the admins in the past month
  console.log(notes);
});

Come si vede i documenti vengono selezionati in base al metodo find per poi essere, eventualmente, sottoposti a valutazioni tramite where: nella seconda query where specifica il campo da valutare e mediante gt (maggiore di) viene specificato il termine di paragone.

Conclusioni

Abbiamo così fatto una rapida introduzione a Mongoose, ambiente che mira a rendere più produttivo lo sviluppatore nell’integrazione di un database MongoDB in un’applicazione Node.js: impiantiamo un Model e gestiamo subito i nostri dati. Restano inoltre aperte possibilità di estensione mediante ulteriori moduli che offrono nuove vie di interazione: il pensiero vola subito ad Express che in un contesto simile permette di esporre il tutto tramite API REST.