cubeforall-dbconnection/mongoose.js

A centralized MongoDB connection handler with connection pooling and graceful shutdown support.

const mongoose = require('mongoose');

const connections = {}; // Store multiple connections by name

/**
 * Connect to a specific MongoDB Atlas instance dynamically
 * @param {string} name - Unique name for the connection (e.g., 'platformMongo', 'boxMongo')
 * @param {string} uri - MongoDB Atlas connection string
 * @param {object} options - Additional Mongoose options
 */
async function connectToMongoose(name, uri, options = {}) {
  if (connections[name]) {
    console.log(`🔗 MongoDB Atlas connection "${name}" already exists.`);
    return connections[name];
  }

  try {
    console.log(`🌍 Connecting to MongoDB Atlas "${name}"...`);

    const defaultOptions = {
      useNewUrlParser: true,
      useUnifiedTopology: true,
      ...options,
    };

    const connection = await mongoose.createConnection(uri, defaultOptions);

    connection.on('connected', () => console.log(`✅ Connected: ${name}`));
    connection.on('error', (err) => console.error(`❌ Error (${name}):`, err));
    connection.on('disconnected', () => console.log(`🛑 Disconnected: ${name}`));

    connections[name] = connection;
    return connection;
  } catch (err) {
    console.error(`❌ Failed to connect to "${name}":`, err);
    throw err;
  }
}

/**
 * Get existing connection by name
 * @param {string} name
 * @returns {Connection} - Mongoose Connection instance
 */
function getConnectionMongoose(name) {
  return connections[name] || null;
}

/**
 * Close all active connections
 */
async function closeAllConnectionsMongoose() {
  for (const [name, conn] of Object.entries(connections)) {
    await conn.close();
    console.log(`🛑 Closed connection: ${name}`);
  }
}

module.exports = {
  connectToMongoose,
  getConnectionMongoose,
  closeAllConnectionsMongoose,
};