How do you keep mongodb connection open in NextJS

[redimongo]

So I have a number of API files that need to connect to mongodb, unlike when I run a NodeJS app I can put the mongodb connector inside the app.js file which opens and then I can connect to that connector.

However it seems that in NextJS every time I run the api code it is making a new connection which is causing me to reach my limit of 500 connections.

I am using the native MongoDB NodeJS drive.

I am using the following (every time the page is requested - so no wonder it is making a new connection. is there a better way to do this?

const uri = process.env.MONGODB_URI
  
  let clientPromise
  const options = {}
  let client = new MongoClient(uri, options)
  clientPromise = client.connect()

In a native NodeJS app we do it like this

app.js

import express from 'express';
import Promise from 'bluebird';
import logger from 'winston';
import { MongoClient } from 'mongodb';
import config from './config';
import usersRestApi from './api/users';

const app = express();

app.use('/api/users', usersRestApi);

app.get('/', (req, res) => {
  res.send('Hello World');
});

// Create a MongoDB connection pool and start the application
// after the database connection is ready
MongoClient.connect(config.database.url, { promiseLibrary: Promise }, (err, db) => {
  if (err) {
    logger.warn(`Failed to connect to the database. ${err.stack}`);
  }
  app.locals.db = db;
  app.listen(config.port, () => {
    logger.info(`Node.js app is listening at http://localhost:${config.port}`);
  });
});

then in ./api/users

import { Router } from 'express';
import { ObjectID } from 'mongodb';

const router = new Router();

router.get('/:id', async (req, res, next) => {
  try {
    const db = req.app.locals.db;
    const id = new ObjectID(req.params.id);
    const user = await db.collection('user').findOne({ _id: id }, {
      email: 1,
      firstName: 1,
      lastName: 1
    });

    if (user) {
      user.id = req.params.id;
      res.send(user);
    } else {
      res.sendStatus(404);
    }
  } catch (err) {
    next(err);
  }
});

export default router;

But this does not seem to work in _app.js for NextJS

[tubbo]

This is kind of a problem with all databases in the serverless world, as they all require persistent connections and thus can suffer from connection pool issues. Products like PlanetScale and Prisma Data Platform help solve this for SQL DBs (with very low connection limits), but unless you're receiving an enormous amount of traffic on your API routes, I'm wondering why you are hitting the 500 connection limit here?

It might be worth looking into how long each query is taking, as 500 requests on a poorly performing query could do this no matter what serverless framework you're using. Is everything indexed? Are you using aggregations?

[redimongo]

yes we did, here our code. note we disabled disconnectFromDatabase

/libraries/mongodb.ts

import { MongoClient } from 'mongodb';

const uri = process.env.MONGODB_URI as string; // your mongodb connection string
const options = {};

declare global {
  var _mongoClientPromise: Promise<MongoClient>;
}

class Singleton {
  private static _instance: Singleton;
  private _client: MongoClient;
  private _clientPromise: Promise<MongoClient>;

  private constructor() {
    this._client = new MongoClient(uri, options);
    this._clientPromise = this._client.connect();
    if (process.env.NODE_ENV === 'development') {
      // In development mode, use a global variable so that the value
      // is preserved across module reloads caused by HMR (Hot Module Replacement).
      global._mongoClientPromise = this._clientPromise;
    }
  }

  public static get instance() {
    if (!this._instance) {
      this._instance = new Singleton();
    }
    return this._instance;
  }

  public get clientPromise() {
    return this._clientPromise;
  }

  public get client() {
    return this._client;
  }

  public get db() {
    return this._client.db(process.env.MONGODB_DB as string);
  }
}

const singleton = Singleton.instance;

// The connectToDatabase function
export async function connectToDatabase() {
  await singleton.clientPromise;
  return { client: singleton.client, db: singleton.db };
}

export async function disconnectFromDatabase() {
 /*if (cachedClient && !isConnecting) {
    await cachedClient.close();
    console.log('MongoDB connection closed');
    cachedClient = null;
    cachedDb = null;
  } else {
    console.log('No active MongoDB connection to close or connection is in the process of connecting');
  }*/
}

[suitux]

yes we did, here our code. note we disabled disconnectFromDatabase

/libraries/mongodb.ts

import { MongoClient } from 'mongodb';

const uri = process.env.MONGODB_URI as string; // your mongodb connection string
const options = {};

declare global {
  var _mongoClientPromise: Promise<MongoClient>;
}

class Singleton {
  private static _instance: Singleton;
  private _client: MongoClient;
  private _clientPromise: Promise<MongoClient>;

  private constructor() {
    this._client = new MongoClient(uri, options);
    this._clientPromise = this._client.connect();
    if (process.env.NODE_ENV === 'development') {
      // In development mode, use a global variable so that the value
      // is preserved across module reloads caused by HMR (Hot Module Replacement).
      global._mongoClientPromise = this._clientPromise;
    }
  }

  public static get instance() {
    if (!this._instance) {
      this._instance = new Singleton();
    }
    return this._instance;
  }

  public get clientPromise() {
    return this._clientPromise;
  }

  public get client() {
    return this._client;
  }

  public get db() {
    return this._client.db(process.env.MONGODB_DB as string);
  }
}

const singleton = Singleton.instance;

// The connectToDatabase function
export async function connectToDatabase() {
  await singleton.clientPromise;
  return { client: singleton.client, db: singleton.db };
}

export async function disconnectFromDatabase() {
 /*if (cachedClient && !isConnecting) {
    await cachedClient.close();
    console.log('MongoDB connection closed');
    cachedClient = null;
    cachedDb = null;
  } else {
    console.log('No active MongoDB connection to close or connection is in the process of connecting');
  }*/
}

And with this scripts, how many connections to mongo do you get?

How many users there are in your app?

I assume that you are deployed in Vercel?

Thanks!

[redimongo]

About 20 but it depends on traffic.

[suitux]

About 20 but it depends on traffic.

20 users connections with more or less how much traffic?

[redimongo]

I would recommend you give it a try and have a look at your own usage, this is the code that was recommended by reddit and also we have 6 servers over 10 scripts accessing the same database, we get around 20-80 connections at a time, well below the 500 max connections.

We host podcasts, so we always have people connecting to our database retrieving and posting podcast episodes.

[abdifitahabdulkadir]

Keeping Database connection a live throughout entire lifecycle of your application to avoid resource exhausted and effective managing of single connection in all requests is key to improve your app performance and overall usability of your app.

take a look my in depth analysis of how you can do this by implementing Singleton Design pattern in Nextjs👇
Singleton Design pattern In Mongodb and Nextjs