Multiple MongoDB Connections in a Single Application

1
npm i express@4.18.2 mongoose@7.5.3

1
PRIMARY_CONN_STR=mongodb+srv://…
2
SECONDARY_CONN_STR=mongodb+srv://…

1
const mongoose = require("mongoose");
2
3
module.exports = (uri, options = {}) => {
4
    // By default, Mongoose skips properties not defined in the schema (strictQuery). Adjust it based on your configuration.
5
    mongoose.set('strictQuery', true);
6
7
    // Connect to MongoDB
8
    mongoose.connect(uri, options)
9
        .then()
10
        .catch(err => console.error("MongoDB primary connection failed, " + err));
11
12
    // Event handling
13
    mongoose.connection.once('open', () => console.info("MongoDB primary connection opened!"));
14
    mongoose.connection.on('connected', () => console.info("MongoDB primary connection succeeded!"));
15
    mongoose.connection.on('error', (err) => {
16
        console.error("MongoDB primary connection failed, " + err);
17
        mongoose.disconnect();
18
    });
19
    mongoose.connection.on('disconnected', () => console.info("MongoDB primary connection disconnected!"));
20
21
    // Graceful exit
22
    process.on('SIGINT', () => {
23
        mongoose.connection.close().then(() => {
24
            console.info("Mongoose primary connection disconnected through app termination!");
25
            process.exit(0);
26
        });
27
    });
28
}

1
const mongoose = require("mongoose");
2
3
module.exports = (options = {}) => {
4
    // Schema for Product
5
    return new mongoose.Schema(
6
        {
7
            store: {
8
                _id: mongoose.Types.ObjectId, // Reference-id to the store collection
9
                name: String
10
            },
11
            name: String
12
            // add required properties
13
        }, 
14
        options
15
    );
16
}

1
// Primary Connection (Change the variable name as per your .env configuration!)
2
// Establish the primary MongoDB connection using the connection string variable declared in the Prerequisites section.
3
require("./db.primary.js")(process.env.PRIMARY_CONN_STR, {
4
    // (optional) connection options
5
});
6
7
// Import Product Schema
8
const productSchema = require("./product.schema.js")({
9
    collection: "products",
10
    // Pass configuration options if needed
11
});
12
13
// Create Model
14
const ProductModel = mongoose.model("Product", productSchema);
15
16
// Execute Your Operations Using ProductModel Object
17
(async function () {
18
    let product = await ProductModel.findOne();
19
    console.log(product);
20
})();

1
const mongoose = require("mongoose");
2
3
module.exports = (uri, options = {}) => {
4
    // Connect to MongoDB
5
    const db = mongoose.createConnection(uri, options);
6
    
7
    // By default, Mongoose skips properties not defined in the schema (strictQuery). Adjust it based on your configuration.
8
    db.set('strictQuery', true);
9
    
10
    // Event handling
11
    db.once('open', () => console.info("MongoDB secondary connection opened!"));
12
    db.on('connected', () => console.info(`MongoDB secondary connection succeeded!`));
13
    db.on('error', (err) => {
14
        console.error(`MongoDB secondary connection failed, ` + err);
15
        db.close();
16
    });
17
    db.on('disconnected', () => console.info(`MongoDB secondary connection disconnected!`));
18
19
    // Graceful exit
20
    process.on('SIGINT', () => {
21
        db.close().then(() => {
22
            console.info(`Mongoose secondary connection disconnected through app termination!`);
23
            process.exit(0);
24
        });
25
    });
26
27
    // Export db object
28
    return db;
29
}

1
// Secondary Connection (Change the variable name as per your .env configuration!)
2
// Establish the secondary MongoDB connection using the connection string variable declared in the Prerequisites section.
3
const db = require("./db.secondary.js")(process.env.SECONDARY_CONN_STR, {
4
    // (optional) connection options
5
});

1
// Import Product Schema
2
const secondaryProductSchema = require("./product.schema.js")({
3
    collection: "products",
4
    // Pass configuration options if needed
5
});
6
7
// Create Model
8
const SecondaryProductModel = db.model("Product", secondaryProductSchema);
9
10
// Execute Your Operations Using SecondaryProductModel Object
11
(async function () {
12
    let product = await SecondaryProductModel.findOne();
13
    console.log(product);
14
})();

1
// Import Product Schema
2
const secondaryProductSchema = require("./product.schema.js")({
3
    collection: "products",
4
    strict: false
5
    // Pass configuration options if needed
6
});
7
8
// Create Model
9
const SecondaryProductModel = db.model("Product", secondaryProductSchema);
10
11
// Execute Your Operations Using SecondaryProductModel Object
12
(async function () {
13
    let product = await SecondaryProductModel.findOne();
14
    console.log(product);
15
})();

1
// Import Product Schema
2
const secondaryProductSchema = require("./product.schema.js")({
3
    collection: "products",
4
    // strict: false // that doesn't adhere strictly to the schema!
5
    // Pass configuration options if needed
6
});
7
8
// Create a connection for 'Store A'
9
const storeA = db.useDb('StoreA');
10
11
// Create Model
12
const SecondaryStoreAProductModel = storeA.model("Product", secondaryProductSchema);
13
14
// Execute Your Operations Using SecondaryStoreAProductModel Object
15
(async function () {
16
    let product = await SecondaryStoreAProductModel.findOne();
17
    console.log(product);
18
})();
19
20
// Create a connection for 'Store B'
21
const storeB = db.useDb('StoreB');
22
23
// Create Model
24
const SecondaryStoreBProductModel = storeB.model("Product", secondaryProductSchema);
25
26
// Execute Your Operations Using SecondaryStoreBProductModel Object
27
(async function () {
28
    let product = await SecondaryStoreBProductModel.findOne();
29
    console.log(product);
30
})();

1
// Function to get connection object for particular store's database
2
function getStoreConnection(storeId) {
3
    return db.useDb("Store"+storeId, { useCache: true });
4
}
5
6
// Create a connection for 'Store A'
7
const store = getStoreConnection("A");
8
9
// Create Model
10
const SecondaryStoreProductModel = store.model("Product", secondaryProductSchema);
11
12
// Execute Your Operations Using SecondaryStoreProductModel Object
13
(async function () {
14
    let product = await SecondaryStoreProductModel.findOne();
15
    console.log(product);
16
})();