Mongoose e database multipli in un singolo progetto node.js

Sto facendo un progetto Node.js che contiene sottoprogetti. Un sottoprogetto avrà un database Mongodb e Mongoose verrà utilizzato per il wrapping e l'interrogazione di db. Ma il problema è

• Mongoose non consente di utilizzare più database in una singola istanza di mangusta poiché i modelli sono costruiti su una connessione.

• Per utilizzare più istanze di mangusta, Node.js non consente più istanze di moduli poiché ha un sistema di memorizzazione nella cache in formato require(). So disabilitare la memorizzazione nella cache del modulo in Node.js ma penso che non sia la buona soluzione in quanto è necessaria solo la mangusta.

  Ho provato a usare createConnection()e openSet()in mangusta, ma non era la soluzione.

  Ho provato a copiare in profondità l'istanza di mongoose ( http://blog.imaginea.com/deep-copy-in-javascript/ ) per passare nuove istanze di mongoose al sottoprogetto, ma viene lanciato RangeError: Maximum call stack size exceeded.

Voglio sapere se esiste comunque l'utilizzo di più database con mangusta o qualsiasi soluzione alternativa per questo problema? Perché penso che la mangusta sia abbastanza facile e veloce. O altri moduli come raccomandazioni?

Una cosa che puoi fare è che potresti avere sottocartelle per ogni progetto. Quindi, installa mongoose in quelle sottocartelle e require () mongoose dalle proprie cartelle in ogni sotto-applicazione. Non dalla radice del progetto o da globale. Quindi un sottoprogetto, un'installazione di mangusta e un'istanza di mangusta.

-app_root/
--foo_app/
---db_access.js
---foo_db_connect.js
---node_modules/
----mongoose/
--bar_app/
---db_access.js
---bar_db_connect.js
---node_modules/
----mongoose/

In foo_db_connect.js

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/foo_db');
module.exports = exports = mongoose;

In bar_db_connect.js

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/bar_db');
module.exports = exports = mongoose;

Nei file db_access.js

var mongoose = require("./foo_db_connect.js"); // bar_db_connect.js for bar app

Ora puoi accedere a più database con mongoose.

Secondo il manuale fine , createConnection() può essere utilizzato per connettersi a più database.

Tuttavia, è necessario creare modelli separati per ogni connessione / database:

var conn      = mongoose.createConnection('mongodb://localhost/testA');
var conn2     = mongoose.createConnection('mongodb://localhost/testB');

// stored in 'testA' database
var ModelA    = conn.model('Model', new mongoose.Schema({
  title : { type : String, default : 'model in testA database' }
}));

// stored in 'testB' database
var ModelB    = conn2.model('Model', new mongoose.Schema({
  title : { type : String, default : 'model in testB database' }
}));

Sono abbastanza sicuro che puoi condividere lo schema tra di loro, ma devi controllare per esserne sicuro.

Abbastanza tardi ma questo potrebbe aiutare qualcuno. Le risposte attuali presumono che tu stia utilizzando lo stesso file per le tue connessioni e modelli.

Nella vita reale, c'è un'alta probabilità che tu stia suddividendo i tuoi modelli in file diversi. Puoi usare qualcosa di simile nel tuo file principale:

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

const db = mongoose.connection;

db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', () => {
  console.log('connected');
});

che è proprio come è descritto nei documenti. E poi nei tuoi file di modello, fai qualcosa come quanto segue:

import mongoose, { Schema } from 'mongoose';

const userInfoSchema = new Schema({
  createdAt: {
    type: Date,
    required: true,
    default: new Date(),
  },
  // ...other fields
});

const myDB = mongoose.connection.useDb('myDB');

const UserInfo = myDB.model('userInfo', userInfoSchema);

export default UserInfo;

Dove myDB è il nome del database.

Come approccio alternativo, Mongoose esporta un costruttore per una nuova istanza nell'istanza predefinita. Quindi qualcosa del genere è possibile.

var Mongoose = require('mongoose').Mongoose;

var instance1 = new Mongoose();
instance1.connect('foo');

var instance2 = new Mongoose();
instance2.connect('bar');

Ciò è molto utile quando si lavora con origini dati separate e anche quando si desidera avere un contesto di database separato per ogni utente o richiesta. Dovrai stare attento, poiché è possibile creare MOLTE connessioni quando lo fai. Assicurati di chiamare disconnect () quando le istanze non sono necessarie e anche di limitare la dimensione del pool creato da ciascuna istanza.

Soluzione un po 'ottimizzata (almeno per me). scrivilo in un file db.js e richiedilo dove richiesto e chiamalo con una chiamata di funzione e sei a posto.

   const MongoClient = require('mongodb').MongoClient;
    async function getConnections(url,db){
        return new Promise((resolve,reject)=>{
            MongoClient.connect(url, { useUnifiedTopology: true },function(err, client) {
                if(err) { console.error(err) 
                    resolve(false);
                }
                else{
                    resolve(client.db(db));
                }
            })
        });
    }

    module.exports = async function(){
        let dbs      = [];
        dbs['db1']     = await getConnections('mongodb://localhost:27017/','db1');
        dbs['db2']     = await getConnections('mongodb://localhost:27017/','db2');
        return dbs;
    };