jak połączyć się z mongodb synchronicznie w nodejs

Question

Chcę skorzystać z funkcji obietnic, gdzie w I można połączyć się z mongodb synchronicznie i mogę ponownie wykorzystać połączenie, przekazując go do różnych modułów.

Oto coś, co wymyśliłem

class MongoDB { 

    constructor(db,collection) {  
     this.collection = db.collection(collection); 
    } 

    find(query, projection) { 
     if(projection) 
      return this.collection.find(query, projection); 
     else 
      return this.collection.find(query); 
    } 
} 

class Crew extends MongoDB { 

    constructor(db) {   
     super(db,'crews'); 
    } 

    validate() { 

    } 
} 

Chcę skonfigurować połączenie gdzieś w moim początkowym kodu jak poniżej, a następnie ponowne podłączenie do różnych klas, podobnie jak jak mangusta lub mnich robi ale przy użyciu tylko pakietu native-mongodb-native.

MongoClient.connect(url) 
      .then((err,dbase) => { 
       global.DB = dbase; 
       }); 


var Crew = new CrewModel(global.DB); 


Crew.find({}) 
    .then(function(resp) { 
     console.log(resp); 
    }); 

Teraz powraca db niezdefiniowane wewnątrz głównej klasy MongoDB i nie jestem w stanie do debugowania ten jeden przez google lub dokumentacji.

Edytuj: Przyjąłem, że obietnica była synchroniczna, ale tak nie jest.

Answer 1

Aby ponownie użyć połączenia, utworzyłbym moduł taki jak ten.

module.exports = { 

    connect: function(dbName, callback) { 
     MongoClient.connect(dbName, function(err, db) { 

     _db = db; 
     return callback(err); 
    }); 
}, 

    getDb: function() { 
     return _db; 
    } 
}; 

Po tym można połączyć się z bazą danych przed uruchomieniem aplikacji

MongoConnection.connect("mongodb://localhost:27017/myDatabase", function(err){ 
    app.listen(3000, function() { 
     // you code 
    }); 
}); 

Mając utworzony moduł w pliku js można po prostu wykorzystać wymagać aby uzyskać databaseConnection

var dbConnection = require("./myMongoConnection.js"); 

i uzyskać połączenie z użyciem

var db = MongoConnection.getDb(); 

Answer 2

Inna opcja przy użyciu klas ES6 tworzy obiekt singleton, do którego można uzyskać dostęp wielokrotnie. Inspiracją jest odpowiedź użytkownika @ user3134009: here.

const EventEmitter = require('events'); 
const MongoClient = require('mongodb').MongoClient; 
const config = require('config'); 

let _db = null; 

class MongoDBConnection extends EventEmitter { 
    constructor() { 
    super(); 
    this.emit("dbinit", this); 
    if (_db == null) { 
     console.log("Connecting to MongoDB..."); 
     MongoClient.connect(config.dbs.mongo.url, config.dbs.mongo.options, 
(err, db) => { 
     if (err) { 
      console.error("MongoDB Connection Error", err); 
      _db = null; 
     } else { 
      console.log("Connected to MongoDB", config.dbs.mongo.url); 
      db.on('close',() => { console.log("MongoDB closed", arguments); _db = null; }); 
      db.on('reconnect',() => { console.log("MongoDB reconnected", arguments); _db = db; }); 
      db.on('timeout',() => { console.log("MongoDB timeout", arguments); }); 
      _db = db; 
      this.emit('dbconnect', _db); 
     } 
     }); 
    } 
    } 
    getDB() { 
    return _db; 
    } 
} 
module.exports = new MongoDBConnection(); 

Answer 3

mam zmaga się z tym problemem na chwilę, aw szczególności tworzenie i utrzymujących połączenia MongoDB w AWS funkcji lambda całej inwokacji. Dzięki @toszter odpowiedź mam w końcu wymyślić następujące rozwiązanie:

const mongodb = require('mongodb'); 
 
const config = require('./config.json')[env]; 
 
const client = mongodb.MongoClient; 
 

 
const mongodbUri = `mongodb://${config.mongo.user}:${config.mongo.password}@${config.mongo.url}/${config.mongo.database}`; 
 

 

 
const options = { 
 
    poolSize: 100, 
 
    connectTimeoutMS: 120000, 
 
    socketTimeoutMS: 1440000 
 
}; 
 

 
// connection object 
 
let _db = null; 
 

 
class MongoDBConnection { 
 
    constructor() {} 
 

 
    // return a promise to the existing connection or the connection function 
 
    getDB() { 
 
    return (_db ? Promise.resolve(_db) : mConnect()); 
 
    } 
 
} 
 

 
module.exports = new MongoDBConnection(); 
 

 
// transforms into a promise Mongo's client.connect 
 
function mConnect() { 
 
    return new Promise((resolve, reject) => { 
 
    console.log('Connecting to Mongo...'); 
 
    client.connect(mongodbUri, options, (error, db) => { 
 
     if (error) { 
 
     _db = null; 
 
     return reject(error); 
 
     } 
 
     else { 
 
     console.log('Connected to Mongo...'); 
 
     _db = db; 
 
     resolve(db); 
 
     } 
 
    }); 
 
    }); 
 
}

wykorzystać go w sterowniku lub app.js:

const mongoConfig = require('mongoConfig'); 
 
    mongoConfig.getDB() 
 
    .then(db => db.collection('collection').find({})) 
 
    .catch(error => {...});