Node.js mongodb pilote async/await requêtes

J'ai un node.js application à l'aide de mongodb pilote natif.
Dans le processus de la migration de mon code d'application async/await l'aide d'un noeud v8.9.1, j'ai du mal à trouver un moyen élégant pour mongodb requêtes.
Le problème majeur avec mongodb conducteur est, que toutes les requêtes sont à l'aide de rappels lorsque des promesses fonctions sont obligatoires pour les méthodes asynchrones.

Alternatives:

mangouste- les promesses des requêtes obsolète et il les forces à l'aide de modèle de Schéma qui est un peu de surcharge pour mon application.
mongoist- soi-disant grand, parce qu'il construit avec async/await dans l'esprit et entièrement promesse, mais des erreurs avec connexion SSL pour mongodb et les pauvres de la documentation - qui m'a attiré à l'écart de cette solution.

La seule solution que j'ai réussi à mettre en œuvre dans une élégante façon est d'utiliser de rappel-la promesse mnp paquet de convertir mongodb pilote API entièrement promesse.

Frais d'idées pour un élégant, de haute performance?

Est semble avoir besoin d'un ‘co’ paquet. Je suis fondamentalement à la recherche d'un promesse bibliothèque native

OriginalL'auteur Ido Lev | 2017-11-18

C'est le plus petit morceau de code que j'ai trouvé qui est compatible avec Mongo3 et async/await.
Profitez-en!

module.exports = {
  myFunction: async (query) => {
    let db, client;
    try {
      client = await MongoClient.connect(process.env.MONGODB_CONNECTION_STRING, { useNewUrlParser: true });
      db = client.db(dbName);
      return await db.collection(collectionName).find(query).toArray();
    } finally {
      client.close();
    }
  }
}

[dupliquer réponse] cette réponse n'ajoute aucune valeur unique à d'autres réponses, et exécutable extrait de code n'a pas de travail, son utilisation est des plus mauvais.
Probablement oui, j'ai trouvé d'autres réponses pas assez concis

OriginalL'auteur Sovattha Sok

Edit: 'mongodb' v3.x

selon mongoDB ES6 avenir
vous pouvez utiliser ce moyen;

let MongoClient = require('mongodb').MongoClient;
const connectionString = 'mongodb://localhost:27017';

    (async () => {
        let client = await MongoClient.connect(connectionString,
            { useNewUrlParser: true });

        let db = client.db('dbName');
        try {
           const res = await db.collection("collectionName").updateOne({ 
               "someKey": someValue
           }, { $set: someObj }, { upsert: true });

           console.log(`res => ${JSON.stringify(res)}`);
        }
        finally {
            client.close();
        }
    })()
        .catch(err => console.error(err));

C'est beau et c'est exactement ce que je cherchais. Merci!!!!
Depuis la Version 3, MongoClient retourne un client, pas un db objet!
Cela ne fonctionne pas plus. Pouvons-nous obtenir une mise à jour pour les versions récentes de mongodb, s'il vous plaît?

OriginalL'auteur Serhat Ates

18

Grâce. Génial de travailler avec ES6:
```
const middleWare = require('middleWare');
const MONGO = require('mongodb').MongoClient;

router.get('/', middleWare(async (req, res, next) => {
    const db = await MONGO.connect(url);
    const MyCollection = db.collection('MyCollection');
    const result = await MyCollection.find(query).toArray();
    res.send(result);
}))
```
c'est une excellente réponse. Pour quelqu'un d'autre à essayer de comprendre la require('middleware') étape, voici un excellent guide: medium.com/@Abazhenov/...
Cela ne fonctionne pas plus non plus. Toute chance d'une mise à jour?
J'ai négligé mongodb et à l'aide de la mangouste maintenant. Il est fortement recommandé car beaucoup de mises à jour et des promesses de soutien.

OriginalL'auteur Ido Lev
3

Si u ne passe pas un rappel, mongodb client renvoie une promesse.

Officiel MongoDB Node.js le pilote fournit à la fois en fonction de rappel ainsi que Promis en fonction de l'interaction avec MongoDB qui permet aux applications de tirer pleinement parti des nouvelles fonctionnalités dans l'ES6

De l'officiel
docs

OriginalL'auteur Surya
3

Je poste cela comme une réponse parce que je ne peux pas commenter sur Ido Lev de la réponse. Je vais déplacer ce dès que j'aurai atteint 50 points de réputation.

N'oubliez pas de fermer la connexion db. Sinon, il est possible que votre demande ne peut pas se connecter à la db en raison du trop grand nombre de connexions ouvertes (qui m'est arrivé il y a une semaine).

Votre requête peut réussir ou échouer, il est donc logique de fermer la connexion à un finally-bloc.
```
const db = await MongoClient.connect(url);
try {
    const stuff = await db.collection("Stuff").find({});
    //Do something with the result of the query
} finally {
    db.close();
}
```
Mise à jour: Il semble que cela n'a pas de résoudre mon problème. Certaines personnes disent que vous n'avez même pas besoin de fermer la connexion manuellement. Il me semble qu'il est préférable de réutiliser votre connexion à travers vous demande si possible.

Oui! J'essaie d'ouvrir une connexion et la réutiliser pour toutes les opération de base de données nécessaires au traitement de la demande actuelle. Autant que je sache, l'ouverture de la connexion est une opération coûteuse, tandis que les lectures et les écritures sont beaucoup plus légers et peut être fait par le biais d'une seule connexion. La plupart des exemples autour de vous connecter, mettre à jour et fermer tous dans le même bloc de code. Je tiens à conserver ma connexion ouverte dans un contexte partagé pour la rendre accessible à toutes les fonctions.

OriginalL'auteur 0xC0DEBA5E

mangouste trouver Requête à l'Aide de async/await

ne pas Utiliser mongoose.connect en cas de async/await

    var router = require("express").Router()
    var mongoose = require("mongoose")
var await = require("await")
var async = require("async")

    var mongoUrl = "mongodb://localhost:27017/ekaushalnsdc"

    router.get("/async/await/find",async(req, res,  next) => {
      try {
        var db =  await mongoose.createConnection(mongoUrl)
          var colName = db.collection('collectionName')
        var result  = await colName.find({}).toArray()
        res.json(result)
    }catch(ex) {
       res.json(ex.message)
    }
    })

Merci pour ce commentaire. Je pense que de toute façon la connexion doit être créé sur le serveur de l'initiation, de sorte qu'il serait fournies à l'échelle mondiale pour tous les modules.

OriginalL'auteur muthukumar

2

Si vous voulez travailler avec le curseur, sans déchargement de Tableau, vous ne pouvez pas utiliser attendent avec find() ou global (de) fonctions, alors vous devez utiliser le code:

UPD par la Cua:
Pour le cas général, les réponses à l'aide de toArray() sont suffisantes.

Mais lorsque d'énormes collections de documents sont concernés, à l'aide de toArray() dépassent la quantité de RAM disponible. Ainsi, une "haute performance" de la solution dans ces situations ne doivent pas utiliser toArray().

Pour ces cas, vous pouvez utiliser MongoDB ruisseaux, qui fonctionne bien, mais même plus simple que d'utiliser les cours d'eau est de:
```
const cursor = db.collection('name').aggregate(
    [
        {
            "$match": {code: 10}
        },
        {
          "$count": "count"
        }
    ],
    {
        "allowDiskUse": false
    }
)

for (let doc = await cursor.next(); doc != null; doc = await cursor.next()) {
    console.log('aggregate:', doc.count);
}
```
merci de modifier votre réponse donc je vais peut nouveau vote comme utile. Voir Usas commentaire ci-dessus. Besoin d'être édité (sans modification) en raison de Usas explication pour les rares cas où votre réponse est pertinente.

OriginalL'auteur Pax Beach
1

(Basé sur le Pax de la Plage de réponse. Il avait été downvoted, et je voulais ajouter un commentaire expliquant pourquoi, dans certaines situations, Pat la réponse est la meilleure. Je n'ai pas assez de rep pour ajouter des commentaires.)

Pour le cas général, les réponses à l'aide de toArray() sont suffisantes.

Mais quand énorme collections de documents sont concernés, à l'aide de toArray() dépassent la quantité de RAM disponible. Ainsi, une "haute performance" de la solution dans ces situations ne doivent pas utiliser toArray().

Pour ces cas, vous pouvez utiliser MongoDB ruisseaux, qui fonctionne bien, mais même plus simple que d'utiliser les cours d'eau est de:
```
const cursor = db.collection('someCollection').find({})
for (let doc = await cursor.next(); doc; doc = await cursor.next()) {
    //Process the document.
}
```
OriginalL'auteur Usas

Vous devez vous connecter pour publier un commentaire.