web-dev-qa-db-fra.com

Comment utiliser MongoDB avec des promesses dans Node.js?

J'ai essayé de découvrir comment utiliser MongoDB avec Node.js et, dans la documentation, il semble que la méthode recommandée consiste à utiliser des rappels. Maintenant, je sais que c'est juste une question de préférence, mais je préfère vraiment utiliser des promesses.

Le problème est que je n'ai pas trouvé comment les utiliser avec MongoDB. En effet, j'ai essayé ce qui suit:

var MongoClient = require('mongodb').MongoClient;

var url = 'mongodb://localhost:27017/example';

MongoClient.connect(url).then(function (err, db) {
    console.log(db);
});

Et le résultat est undefined. Dans ce cas, il semble que ce ne soit pas la manière de le faire.

Est-il possible d'utiliser mongo db dans Node avec des promesses au lieu de rappels?

javascriptnode.jsmongodb
64
user1620696

Votre approche est presque correcte, juste une petite erreur dans votre argument

var MongoClient = require('mongodb').MongoClient
var url = 'mongodb://localhost:27017/example'
MongoClient.connect(url)
  .then(function (db) { // <- db as first argument
    console.log(db)
  })
  .catch(function (err) {})
100
Green

Puisqu'aucune des réponses ci-dessus ne dit comment faire cela sans bluebird, q ou toute autre bibliothèque de fantaisie, laissez-moi ajouter mes 2 centimes à ce sujet.

Voici comment faire une insertion avec des promesses natives ES6

    'use strict';

const
    constants = require('../core/constants'),
    mongoClient = require('mongodb').MongoClient;



function open(){

    // Connection URL. This is where your mongodb server is running.
    let url = constants.MONGODB_URI;
    return new Promise((resolve, reject)=>{
        // Use connect method to connect to the Server
        mongoClient.connect(url, (err, db) => {
            if (err) {
                reject(err);
            } else {
                resolve(db);
            }
        });
    });
}

function close(db){
    //Close connection
    if(db){
        db.close();
    }
}

let db = {
    open : open,
    close: close
}

module.exports = db;

J'ai défini ma méthode open () comme celle renvoyant une promesse. Pour effectuer une insertion, voici l'extrait de code ci-dessous.

function insert(object){
    let database = null;
    zenodb.open()
    .then((db)=>{
        database = db;
        return db.collection('users')    
    })
    .then((users)=>{
        return users.insert(object)
    })
    .then((result)=>{
        console.log(result);
        database.close();
    })
    .catch((err)=>{
        console.error(err)
    })
}



insert({name: 'Gary Oblanka', age: 22});

J'espère que ça t'as aidé. Si vous avez des suggestions pour améliorer la situation, faites-le moi savoir car je suis disposé à m'améliorer moi-même :)

16
PirateApp

Ceci est une réponse générale pour Comment utiliser MongoDB avec des promesses dans Node.js?

mongodb retournera une promesse si le paramètre de rappel est omis

Avant de convertir en promesse

var MongoClient = require('mongodb').MongoClient,
dbUrl = 'mongodb://db1.example.net:27017';

MongoClient.connect(dbUrl,function (err, db) {
    if (err) throw err
    else{
        db.collection("users").findOne({},function(err, data) {
            console.log(data)
        });
    }
})

Après conversion en promesse

//converted
MongoClient.connect(dbUrl).then(function (db) {
    //converted
    db.collection("users").findOne({}).then(function(data) {
         console.log(data)
    }).catch(function (err) {//failure callback
         console.log(err)
    });
}).catch(function (err) {})

Si vous avez besoin de gérer plusieurs requêtes

MongoClient.connect(dbUrl).then(function (db) {

   /*---------------------------------------------------------------*/

    var allDbRequest = [];
    allDbRequest.Push(db.collection("users").findOne({}));
    allDbRequest.Push(db.collection("location").findOne({}));
    Promise.all(allDbRequest).then(function (results) {
        console.log(results);//result will be array which contains each promise response
    }).catch(function (err) {
         console.log(err)//failure callback(if any one request got rejected)
    });

   /*---------------------------------------------------------------*/

}).catch(function (err) {})
9
Sivashanmugam Kannan

Vous pouvez aussi faire async/wait

async function main(){
 let client, db;
 try{
    client = await MongoClient.connect(mongoUrl, {useNewUrlParser: true});
    db = client.db(dbName);
    let dCollection = db.collection('collectionName');
    let result = await dCollection.find();   
    // let result = await dCollection.countDocuments();
    // your other codes ....
    return result.toArray();
 }
 catch(err){ console.error(err); } // catch any mongo error here
 finally{ client.close(); } // make sure to close your connection after
}
5
ginad

ATTENTION Edit:

Comme John Culviner l'a noté, cette réponse est obsolète. Utilisez le pilote, il vient avec des promesses OOTB.

Si vous choisissez d'utiliser bluebird comme bibliothèque de promesses, vous pouvez utiliser la fonction bluebirds promisifyAll() sur MongoClient:

var Promise = require('bluebird');
var MongoClient = Promise.promisifyAll(require('mongodb').MongoClient);

var url = 'mongodb://localhost:27017/example';

MongoClient.connectAsync(url).then(function (db) {
    console.log(db);
}).catch(function(err){
    //handle error
    console.log(err);
});
2
Simon Z.

Solution de travail avec MongoDB version> 3.

var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";


open = (url) => {
    return new Promise((resolve,reject) => {
        MongoClient.connect(url, (err,client) => { //Use "client" insted of "db" in the new MongoDB version
            if (err) {
                reject(err)
            } else {
                resolve({
                    client
                });
            };
        });
    });
};

create = (client) => {
    return new Promise((resolve,reject) => {
        db = client.db("myFirstCollection"); //Get the "db" variable from "client"
        db.collection("myFirstCollection").insertOne({
            name: 'firstObjectName',
            location: 'London'
            }, (err,result)=> {
                if(err){reject(err)}
                else {
                    resolve({
                        id: result.ops[0]._id, //Add more variables if you want
                        client
                    });
                }

            });
    });
};

close = (client) => {
    return new Promise((resolve,reject) => {
        resolve(client.close());
    })

};

open(url)
    .then((c) => {
        clientvar = c.client;
        return create(clientvar)
    }).then((i) => {
        idvar= i.id;
        console.log('New Object ID:',idvar) // Print the ID of the newly created object
        cvar = i.client
        return close(cvar)
    }).catch((err) => {
        console.log(err)
    })
1
Dimitar Zafirov

Vous pouvez utiliser un autre package, tel que mongodb-promise ou promisifier l'API du package mongodb manuellement en construisant vos propres promesses autour de celui-ci ou via un package d'utilitaire de promesse tel que bluebird.promisify

0
markusthoemmes

Il ne semble pas que la méthode connect ait une interface de promesse définie

http://mongodb.github.io/node-mongodb-native/2.1/tutorials/connect/

vous pouvez toujours l'implémenter vous-même dans la bibliothèque de connecteurs Mongodb, mais c'est probablement plus complexe que ce que vous recherchez.

Si vous avez vraiment besoin de travailler avec des promesses, vous pouvez toujours utiliser le polyfill ES6 promise:

https://github.com/stefanpenner/es6-promise

et envelopper votre code de connexion avec cela. Quelque chose comme

var MongoClient = require('mongodb').MongoClient;
var Promise = require('es6-promise').Promise;

var url = 'mongodb://localhost:27017/example';

var promise = new Promise(function(resolve, reject){
    MongoClient.connect(url, function (err, db) {
        if(err) reject(err);
        resolve(db);
    });        
});

promise.then(<resolution code>);
0
andrewkodesgood

Vous devez créer une promesse qui se connecte à Mongo.

Ensuite, définissez votre fonction qui utilise cette promesse: myPromise.then(...).

Par exemple:

function getFromMongo(cb) {
    connectingDb.then(function(db) {

       db.collection(coll).find().toArray(function (err,result){
           cb(result);
       });

    });
}

voici le code complet:

http://jsfiddle.net/t5hdjejg/

0
Maria Maldini