Mongoose et plusieurs bases de données dans un seul projet node.js

Je fais un projet Node.js qui contient des sous-projets. Un sous-projet aura une base de données Mongodb et Mongoose sera utilisé pour encapsuler et interroger db. Mais le problème est

• Mongoose ne permet pas d'utiliser plusieurs bases de données dans une seule instance de mangouste car les modèles sont construits sur une seule connexion.

• Pour utiliser plusieurs instances de mangouste, Node.js n'autorise pas plusieurs instances de module car il dispose d'un système de mise en cache require(). Je sais désactiver la mise en cache du module dans Node.js mais je pense que ce n'est pas la bonne solution car il ne s'agit que de mangouste.

  J'ai essayé d'utiliser createConnection()et openSet()en mangouste, mais ce n'était pas la solution.

  J'ai essayé de copier en profondeur l'instance de mangouste ( http://blog.imaginea.com/deep-copy-in-javascript/ ) pour transmettre de nouvelles instances de mangouste au sous-projet, mais cela lance RangeError: Maximum call stack size exceeded.

Je veux savoir est-il possible d'utiliser plusieurs bases de données avec mangouste ou une solution de contournement pour ce problème? Parce que je pense que la mangouste est assez facile et rapide. Ou d'autres modules comme recommandations?

Une chose que vous pouvez faire est que vous pourriez avoir des sous-dossiers pour chaque projet. Donc, installez mongoose dans ces sous-dossiers et require () mongoose à partir de ses propres dossiers dans chaque sous-application. Pas à partir de la racine du projet ou de global. Donc un sous-projet, une installation mangouste et une instance mangouste.

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

Dans foo_db_connect.js

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

Dans bar_db_connect.js

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

Dans les fichiers db_access.js

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

Désormais, vous pouvez accéder à plusieurs bases de données avec mangouste.

Selon le manuel fin , createConnection() peut être utilisé pour se connecter à plusieurs bases de données.

Cependant, vous devez créer des modèles distincts pour chaque connexion / base de données:

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

Je suis presque sûr que vous pouvez partager le schéma entre eux, mais vous devez vérifier pour vous en assurer.

Assez tard mais cela pourrait aider quelqu'un. Les réponses actuelles supposent que vous utilisez le même fichier pour vos connexions et modèles.

Dans la vraie vie, il y a de fortes chances que vous divisiez vos modèles en différents fichiers. Vous pouvez utiliser quelque chose comme ceci dans votre fichier 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');
});

ce qui est juste comme cela est décrit dans la documentation. Et puis dans vos fichiers de modèle, faites quelque chose comme ceci:

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;

Où myDB est le nom de votre base de données.

Comme approche alternative, Mongoose exporte un constructeur pour une nouvelle instance sur l'instance par défaut. Donc, quelque chose comme ça est possible.

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

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

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

Ceci est très utile lorsque vous travaillez avec des sources de données distinctes, et également lorsque vous souhaitez avoir un contexte de base de données distinct pour chaque utilisateur ou requête. Vous devrez faire attention, car il est possible de créer BEAUCOUP de connexions en faisant cela. Assurez-vous d'appeler disconnect () lorsque les instances ne sont pas nécessaires, et également de limiter la taille du pool créé par chaque instance.

Une solution un peu optimisée (pour moi au moins). écrivez ceci dans un fichier db.js et exigez-le partout où c'est nécessaire et appelez-le avec un appel de fonction et vous êtes prêt à partir.

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