How to connect mongodb to Nextjs without mongoose?

[govindpvenu]

Summary

I am using nextjs 15 app router with mongodb as database.i simply want to fetch data in server component.Here i'm following the official example.

https://github.com/vercel/next.js/tree/canary/examples/with-mongodb

They use this file: mongodb.ts

import { MongoClient } from "mongodb";

if (!process.env.MONGODB_URI) {
  throw new Error('Invalid/Missing environment variable: "MONGODB_URI"');
}

const uri = process.env.MONGODB_URI;
const options = { appName: "devrel.template.nextjs" };

let client: MongoClient;

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).
  let globalWithMongo = global as typeof globalThis & {
    _mongoClient?: MongoClient;
  };

  if (!globalWithMongo._mongoClient) {
    globalWithMongo._mongoClient = new MongoClient(uri, options);
  }
  client = globalWithMongo._mongoClient;
} else {
  // In production mode, it's best to not use a global variable.
  client = new MongoClient(uri, options);
}

// Export a module-scoped MongoClient. By doing this in a
// separate module, the client can be shared across functions.

export default client;

Additional information

But they are not telling how to properly connect to db before making a request

They have this testDatabaseConnection() functoin in actions.ts file,which is called in the page.tsx file.So am i supposed to call this function in every page ?

Additional question: 1.Do i need to cache database connection? 2.Will face any problems in production when lot of users connect to the database?

Note:

I don't want to use mongoose because my use case is different.

Example

No response

[icyJoseph]

1.Do i need to cache database connection?

Not necessarily, because the MongoDB Client, already does socket pooling, so a client can server concurrent requests. What you need to preserve is the client, https://www.mongodb.com/docs/drivers/node/current/faq/#how-does-connection-pooling-work-in-the-node-driver-:

MongoClient supports multiple concurrent requests. For each process, create a client and reuse it for all operations in a process. This practice is more efficient than creating a client for each request.

And the code you've shared already does preserve the client.

To find data you can read through: https://www.mongodb.com/docs/drivers/node/current/usage-examples/findOne/#std-label-node-usage-findone where the client is the client created in the file you shared.

2.Will face any problems in production when lot of users connect to the database?

Again, same point as above.

[suitux]

No. Didn't get any answer :(

My solution is deploy into Railway or any VPS if you want to avoid Serverless Function database connection problems

[Luckysolanki902]

Okay, thanks :(

[Luckysolanki902]

did the mongoclient method from 'mongodb' work? as mentioned above?

[suitux]

The connection works, the problem it's the Serverless Env itself

[Luckysolanki902]

Hey, I resolved the MongoDB connection issue by configuring the connection pool limit to 1 and setting serverSelectionTimeoutMS to 5000 (to fail fast if no server is found). The code is working well for MongoDB now. Here's the updated snippet:

import mongoose from 'mongoose';

const { MONGODB_URI } = process.env;

if (!MONGODB_URI) {
  console.error('MONGODB_URI environment variable not defined.');
  throw new Error('Please define the MONGODB_URI environment variable.');
}

// Global cache to prevent multiple connections in development mode
let cached = global.mongoose;
if (!cached) {
  cached = global.mongoose = { conn: null, promise: null };
}

// Configuration to manage connection pooling and timeouts
const options = {
  bufferCommands: false,
  maxPoolSize: 1,
  minPoolSize: 1,
  serverSelectionTimeoutMS: 5000,   // Fail fast if no server is found
  socketTimeoutMS: 30000,          // Socket idle timeout
  heartbeatFrequencyMS: 10000,     // Ping server every 10 seconds
  maxIdleTimeMS: 10000,            // Reap idle connections after 10 seconds
  waitQueueTimeoutMS: 5000,        // Timeout for connection queue
};

async function connectToDatabase() {
  // Use existing connection if it's already established
  if (cached.conn && cached.conn.readyState === 1) {
    return cached.conn;
  }

  // Wait for an in-progress connection if one exists
  if (cached.promise) {
    cached.conn = await cached.promise;
    return cached.conn;
  }

  // Create a new connection if none exist
  console.info('MongoDB: Initiating a new connection...');

  cached.promise = mongoose.connect(MONGODB_URI, options).then((mongooseInstance) => {
    console.info('MongoDB: Successfully connected.');
    return mongooseInstance;
  }).catch(err => {
    console.error(`MongoDB: Connection error - ${err.message}`);
    cached.promise = null;
    throw err;
  });

  cached.conn = await cached.promise;
  return cached.conn;
}

export default connectToDatabase;

After hours of trying, this finally drastically reduced the number of connections.

While this resolved the MongoDB connection issue, I'm still experiencing problems with other APIs on the serverless platform, particularly when streaming files from AWS for downloads. Considering these issues, I’m thinking of switching to Railway. Currently, I'm on Vercel’s paid plan. Can you please estimate the approximate cost on Railway for a similar setup?