Remplacement des rappels par des promesses dans Node.js

J'ai un module de nœud simple qui se connecte à une base de données et possède plusieurs fonctions pour recevoir des données, par exemple cette fonction:

dbConnection.js:

import mysql from 'mysql';

const connection = mysql.createConnection({
  host: 'localhost',
  user: 'user',
  password: 'password',
  database: 'db'
});

export default {
  getUsers(callback) {
    connection.connect(() => {
      connection.query('SELECT * FROM Users', (err, result) => {
        if (!err){
          callback(result);
        }
      });
    });
  }
};

Le module serait appelé de cette façon à partir d'un module de nœud différent:

app.js:

import dbCon from './dbConnection.js';

dbCon.getUsers(console.log);

Je voudrais utiliser des promesses au lieu de rappels pour renvoyer les données. Jusqu'à présent, j'ai lu sur les promesses imbriquées dans le fil suivant: Ecrire du code propre avec des promesses imbriquées , mais je n'ai pas trouvé de solution assez simple pour ce cas d'utilisation. Quelle serait la bonne façon de revenir en resultutilisant une promesse?

Utiliser la Promiseclasse

Je recommande de jeter un œil aux documents Promise de MDN qui offrent un bon point de départ pour utiliser Promises. Alternativement, je suis sûr qu'il existe de nombreux tutoriels disponibles en ligne. :)

Remarque: les navigateurs modernes prennent déjà en charge la spécification ECMAScript 6 des promesses (voir les documents MDN liés ci-dessus) et je suppose que vous souhaitez utiliser l'implémentation native, sans bibliothèques tierces.

Quant à un exemple concret ...

Le principe de base fonctionne comme ceci:

1. Votre API s'appelle
2. Vous créez un nouvel objet Promise, cet objet prend une seule fonction comme paramètre de constructeur
3. Votre fonction fournie est appelée par l'implémentation sous-jacente et la fonction reçoit deux fonctions - resolveetreject
4. Une fois que vous avez fait votre logique, vous appelez l'un d'entre eux pour remplir la promesse ou la rejeter avec une erreur

Cela peut sembler beaucoup alors voici un exemple réel.

exports.getUsers = function getUsers () {
  // Return the Promise right away, unless you really need to
  // do something before you create a new Promise, but usually
  // this can go into the function below
  return new Promise((resolve, reject) => {
    // reject and resolve are functions provided by the Promise
    // implementation. Call only one of them.

    // Do your logic here - you can do WTF you want.:)
    connection.query('SELECT * FROM Users', (err, result) => {
      // PS. Fail fast! Handle errors first, then move to the
      // important stuff (that's a good practice at least)
      if (err) {
        // Reject the Promise with an error
        return reject(err)
      }

      // Resolve (or fulfill) the promise with data
      return resolve(result)
    })
  })
}

// Usage:
exports.getUsers()  // Returns a Promise!
  .then(users => {
    // Do stuff with users
  })
  .catch(err => {
    // handle errors
  })

Utilisation de la fonctionnalité de langage async / await (Node.js> = 7.6)

Dans Node.js 7.6, le compilateur JavaScript v8 a été mis à niveau avec le support async / await . Vous pouvez maintenant déclarer les fonctions comme étant async, ce qui signifie qu'elles renvoient automatiquement un Promisequi est résolu lorsque la fonction asynchrone termine l'exécution. Dans cette fonction, vous pouvez utiliser le awaitmot - clé pour attendre qu'une autre promesse se résout.

Voici un exemple:

exports.getUsers = async function getUsers() {
  // We are in an async function - this will return Promise
  // no matter what.

  // We can interact with other functions which return a
  // Promise very easily:
  const result = await connection.query('select * from users')

  // Interacting with callback-based APIs is a bit more
  // complicated but still very easy:
  const result2 = await new Promise((resolve, reject) => {
    connection.query('select * from users', (err, res) => {
      return void err ? reject(err) : resolve(res)
    })
  })
  // Returning a value will cause the promise to be resolved
  // with that value
  return result
}

Avec bluebird, vous pouvez utiliser Promise.promisifyAll(et Promise.promisify) pour ajouter des méthodes prêtes pour Promise à n'importe quel objet.

var Promise = require('bluebird');
// Somewhere around here, the following line is called
Promise.promisifyAll(connection);

exports.getUsersAsync = function () {
    return connection.connectAsync()
        .then(function () {
            return connection.queryAsync('SELECT * FROM Users')
        });
};

Et utilisez comme ceci:

getUsersAsync().then(console.log);

ou

// Spread because MySQL queries actually return two resulting arguments, 
// which Bluebird resolves as an array.
getUsersAsync().spread(function(rows, fields) {
    // Do whatever you want with either rows or fields.
});

Ajout de broyeurs

Bluebird prend en charge de nombreuses fonctionnalités, l'une d'elles étant les éliminateurs, elle vous permet de disposer en toute sécurité d'une connexion après sa fin à l'aide de Promise.usinget Promise.prototype.disposer. Voici un exemple de mon application:

function getConnection(host, user, password, port) {
    // connection was already promisified at this point

    // The object literal syntax is ES6, it's the equivalent of
    // {host: host, user: user, ... }
    var connection = mysql.createConnection({host, user, password, port});
    return connection.connectAsync()
        // connect callback doesn't have arguments. return connection.
        .return(connection) 
        .disposer(function(connection, promise) { 
            //Disposer is used when Promise.using is finished.
            connection.end();
        });
}

Ensuite, utilisez-le comme ceci:

exports.getUsersAsync = function () {
    return Promise.using(getConnection()).then(function (connection) {
            return connection.queryAsync('SELECT * FROM Users')
        });
};

Cela mettra automatiquement fin à la connexion une fois la promesse résolue avec la valeur (ou rejetée avec un Error).

Node.js version 8.0.0+:

Vous ne devez pas utiliser Bluebird pour promisify les méthodes de l' API de noeud plus. Parce qu'à partir de la version 8+, vous pouvez utiliser nativement util.promisify :

const util = require('util');

const connectAsync = util.promisify(connection.connectAsync);
const queryAsync = util.promisify(connection.queryAsync);

exports.getUsersAsync = function () {
    return connectAsync()
        .then(function () {
            return queryAsync('SELECT * FROM Users')
        });
};

Maintenant, vous n'avez pas besoin d'utiliser une bibliothèque tierce pour faire la promesse.

En supposant que l'API de votre adaptateur de base de données ne se génère pas d' Promiseselle-même, vous pouvez faire quelque chose comme:

exports.getUsers = function () {
    var promise;
    promise = new Promise();
    connection.connect(function () {
        connection.query('SELECT * FROM Users', function (err, result) {
            if(!err){
                promise.resolve(result);
            } else {
                promise.reject(err);
            }
        });
    });
    return promise.promise();
};

Si l'API de base de données prend en charge, Promisesvous pouvez faire quelque chose comme: (ici, vous voyez la puissance de Promises, votre fluff de rappel disparaît pratiquement)

exports.getUsers = function () {
    return connection.connect().then(function () {
        return connection.query('SELECT * FROM Users');
    });
};

Utilisation .then()pour renvoyer une nouvelle promesse (imbriquée).

Appeler avec:

module.getUsers().done(function (result) { /* your code here */ });

J'ai utilisé une maquette d'API pour mes promesses, votre API peut être différente. Si vous me montrez votre API, je peux l'adapter.

2019:

Utilisez ce module natif const {promisify} = require('util'); pour convertir un ancien modèle de rappel en modèle de promesse afin que vous puissiez obtenir des avantages à partir du async/awaitcode

const {promisify} = require('util');
const glob = promisify(require('glob'));

app.get('/', async function (req, res) {
    const files = await glob('src/**/*-spec.js');
    res.render('mocha-template-test', {files});
});

Lors de la mise en place d'une promesse, vous prenez deux paramètres, resolveet reject. En cas de succès, appelez resolveavec le résultat, en cas d'échec, appelezreject avec l'erreur.

Ensuite, vous pouvez écrire:

getUsers().then(callback)

callbacksera appelé avec le résultat de la promesse renvoyée getUsers, ieresult

En utilisant la bibliothèque Q par exemple:

function getUsers(param){
    var d = Q.defer();

    connection.connect(function () {
    connection.query('SELECT * FROM Users', function (err, result) {
        if(!err){
            d.resolve(result);
        }
    });
    });
    return d.promise;   
}

Le code ci-dessous ne fonctionne que pour le nœud -v> 8.x

J'utilise ce middleware MySQL promis pour Node.js

lire cet article Créer un middleware de base de données MySQL avec Node.js 8 et Async / Await

database.js

var mysql = require('mysql'); 

// node -v must > 8.x 
var util = require('util');


//  !!!!! for node version < 8.x only  !!!!!
// npm install util.promisify
//require('util.promisify').shim();
// -v < 8.x  has problem with async await so upgrade -v to v9.6.1 for this to work. 



// connection pool https://github.com/mysqljs/mysql   [1]
var pool = mysql.createPool({
  connectionLimit : process.env.mysql_connection_pool_Limit, // default:10
  host     : process.env.mysql_host,
  user     : process.env.mysql_user,
  password : process.env.mysql_password,
  database : process.env.mysql_database
})


// Ping database to check for common exception errors.
pool.getConnection((err, connection) => {
if (err) {
    if (err.code === 'PROTOCOL_CONNECTION_LOST') {
        console.error('Database connection was closed.')
    }
    if (err.code === 'ER_CON_COUNT_ERROR') {
        console.error('Database has too many connections.')
    }
    if (err.code === 'ECONNREFUSED') {
        console.error('Database connection was refused.')
    }
}

if (connection) connection.release()

 return
 })

// Promisify for Node.js async/await.
 pool.query = util.promisify(pool.query)



 module.exports = pool

Vous devez mettre à niveau le nœud -v> 8.x

vous devez utiliser la fonction async pour pouvoir utiliser await.

exemple:

   var pool = require('./database')

  // node -v must > 8.x, --> async / await  
  router.get('/:template', async function(req, res, next) 
  {
      ...
    try {
         var _sql_rest_url = 'SELECT * FROM arcgis_viewer.rest_url WHERE id='+ _url_id;
         var rows = await pool.query(_sql_rest_url)

         _url  = rows[0].rest_url // first record, property name is 'rest_url'
         if (_center_lat   == null) {_center_lat = rows[0].center_lat  }
         if (_center_long  == null) {_center_long= rows[0].center_long }
         if (_center_zoom  == null) {_center_zoom= rows[0].center_zoom }          
         _place = rows[0].place


       } catch(err) {
                        throw new Error(err)
       }