Mongoose e vários bancos de dados no projeto node.js único

Estou fazendo um projeto Node.js que contém subprojetos. Um subprojeto terá um banco de dados Mongodb e o Mongoose será usado para agrupar e consultar o banco de dados. Mas o problema é

• O Mongoose não permite usar vários bancos de dados em uma única instância de mangusto, pois os modelos são construídos em uma conexão.

• Para usar várias instâncias de mangusto, o Node.js não permite várias instâncias de módulo, pois possui o sistema de cache require(). Eu sei desativar o cache do módulo no Node.js, mas acho que não é a boa solução, pois é apenas necessário para o mangusto.

  Eu tentei usar createConnection()e openSet()em mangusto, mas não era a solução.

  Tentei copiar profundamente a instância do mangusto ( http://blog.imaginea.com/deep-copy-in-javascript/ ) para passar novas instâncias do mangusto para o subprojeto, mas está sendo lançada RangeError: Maximum call stack size exceeded.

Eu quero saber se há alguma maneira de usar vários bancos de dados com mangusto ou alguma solução alternativa para esse problema? Porque acho que o mangusto é bem fácil e rápido. Ou quaisquer outros módulos como recomendações?

Uma coisa que você pode fazer é ter subpastas para cada projeto. Portanto, instale o mangusto nessas subpastas e exija () o mangusto de suas próprias pastas em cada sub-aplicativo. Não da raiz do projeto ou da global. Então, um subprojeto, uma instalação de mangusto e uma instância de mangusto.

-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/

Em foo_db_connect.js

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

Em bar_db_connect.js

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

Nos arquivos db_access.js

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

Agora, você pode acessar vários bancos de dados com o mangusto.

De acordo com o manual , createConnection() pode ser usado para conectar-se a vários bancos de dados.

No entanto, você precisa criar modelos separados para cada conexão / banco de dados:

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' }
}));

Tenho certeza de que você pode compartilhar o esquema entre eles, mas é necessário verificar para ter certeza.

Muito tarde, mas isso pode ajudar alguém. As respostas atuais assumem que você está usando o mesmo arquivo para suas conexões e modelos.

Na vida real, há uma grande chance de você estar dividindo seus modelos em arquivos diferentes. Você pode usar algo parecido com isto em seu arquivo principal:

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

const db = mongoose.connection;

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

que é exatamente como é descrito nos documentos. E então nos arquivos de modelo, faça algo como o seguinte:

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;

Onde myDB é o nome do seu banco de dados.

Como uma abordagem alternativa, o Mongoose exporta um construtor para uma nova instância na instância padrão. Então, algo assim é possível.

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

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

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

Isso é muito útil ao trabalhar com fontes de dados separadas e também quando você deseja ter um contexto de banco de dados separado para cada usuário ou solicitação. Você precisará ter cuidado, pois é possível criar muitas conexões ao fazer isso. Certifique-se de chamar o método desconectar () quando as instâncias não forem necessárias e também limitar o tamanho do pool criado por cada instância.

Uma solução um pouco otimizada (pelo menos para mim). grave isso em um arquivo db.js e exija isso sempre que necessário e chame-o com uma chamada de função e você estará pronto.

   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;
    };