Mongoose y múltiples bases de datos en un solo proyecto node.js

Estoy haciendo un proyecto Node.js que contiene subproyectos. Un subproyecto tendrá una base de datos Mongodb y Mongoose se utilizará para envolver y consultar la base de datos. Pero el problema es

• Mongoose no permite el uso de varias bases de datos en una sola instancia de mangosta, ya que los modelos se basan en una sola conexión.

• Para usar múltiples instancias de mangosta, Node.js no permite múltiples instancias de módulo ya que tiene un sistema de almacenamiento en caché en require(). Sé deshabilitar el almacenamiento en caché del módulo en Node.js, pero creo que no es la buena solución, ya que solo es necesario para la mangosta.

  He intentado usar createConnection()y openSet()en mangosta, pero no fue la solución.

  Intenté copiar en profundidad la instancia de mangosta ( http://blog.imaginea.com/deep-copy-in-javascript/ ) para pasar nuevas instancias de mangosta al subproyecto, pero arroja RangeError: Maximum call stack size exceeded.

Quiero saber, ¿hay alguna forma de usar múltiples bases de datos con mangosta o alguna solución para este problema? Porque creo que la mangosta es bastante fácil y rápida. ¿O algún otro módulo como recomendación?

Una cosa que puede hacer es tener subcarpetas para cada proyecto. Entonces, instale mangosta en esas subcarpetas y requiera () mangosta de sus propias carpetas en cada sub-aplicaciones. No desde la raíz del proyecto ni desde global. Entonces, un subproyecto, una instalación de mangosta y una instancia de mangosta.

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

En foo_db_connect.js

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

En bar_db_connect.js

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

En archivos db_access.js

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

Ahora, puede acceder a múltiples bases de datos con mangosta.

De acuerdo con el manual fino , createConnection() se puede utilizar para conectarse a varias bases de datos.

Sin embargo, debe crear modelos separados para cada conexión / base de datos:

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

Estoy bastante seguro de que puede compartir el esquema entre ellos, pero debe verificarlo para asegurarse.

Bastante tarde, pero esto podría ayudar a alguien. Las respuestas actuales asumen que está utilizando el mismo archivo para sus conexiones y modelos.

En la vida real, existe una alta probabilidad de que divida sus modelos en diferentes archivos. Puede usar algo como esto en su archivo 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 es exactamente como se describe en los documentos. Y luego, en sus archivos de modelo, haga algo como lo siguiente:

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;

Donde myDB es el nombre de su base de datos.

Como enfoque alternativo, Mongoose exporta un constructor para una nueva instancia en la instancia predeterminada. Entonces, algo como esto es posible.

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

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

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

Esto es muy útil cuando se trabaja con fuentes de datos independientes y también cuando se desea tener un contexto de base de datos independiente para cada usuario o solicitud. Deberá tener cuidado, ya que es posible crear MUCHAS conexiones al hacer esto. Asegúrese de llamar a desconectar () cuando las instancias no sean necesarias y también de limitar el tamaño del grupo creado por cada instancia.

Una solución un poco optimizada (para mí al menos). escriba esto en un archivo db.js y solicítelo donde sea necesario y llámelo con una llamada de función y estará listo para comenzar.

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