How to initialize mongodb correctly in instrumentation.ts?

[dackon]

I initialized mongodb in instrumentation.ts successfully, I printed cacheDB, and it is not null. But latter I call getDatabase, it is null, why?

@/app/lib/mongodb.ts

"use server";

import { MongoClient, Db } from "mongodb";
import { ServiceConfig } from "@/app/lib/definition";
import logger from "@/app/lib/logger";

let cachedClient: MongoClient | null = null;
let cachedDB: Db | null = null;

export async function initDatabase(config: ServiceConfig) {
  if (cachedClient && cachedDB) {
    return { client: cachedClient, db: cachedDB };
  }

  try {
    const client = new MongoClient(config.mongodb.url);
    await client.connect();
    const db = client.db(config.mongodb.db);
    cachedClient = client;
    cachedDB = db;

    setInterval(() => {
      if (cachedDB) {
        console.log("cachedDB is not null");
      }
    }, 10000);

    // await createIndex(db);
    return { client, db };
  } catch (error) {
    logger.error(`mongodb::initDatabase: Got error ${error}.`);
    throw error;
  }
}

export async function getDatabase(): Promise<Db> {
  console.log("getDatabase", cachedDB);
  if (!cachedDB) {
    throw new Error(
      "Database is not initialized. Call `initDatabase` with configuration first."
    );
  }

  return cachedDB;
}

[dackon]

Asked ChatGPT, it gave an ugly but working solution, is there any better way?

const globalForMongo = global as unknown as {
  cachedClient: MongoClient | null;
  cachedDB: Db | null;
};

[antoniobrandao]

@dackon have you found the solution? Same problem here

[dackon]

Thank you very much

[tikiram]

Hey @antoniobrandao , are you using this db connection for your overall application? if that's the case I had the same idea but I didn't find any "official" docs about using the instrumentation file for a Mongo connection, somehow I found this discussion, is this solution a good workaround? or should I stick to call await dbConnect everywhere? I don't have much experience working with Next

[dackon]

I think it is a good idea to initialize the database connection and anything else that needs to be initialized when starting the service. If there are any configuration errors, we can find them quickly instead of relying on client requests.

[antoniobrandao]

@tikiram the fact that there is sparse information online about using instrumentation is itself a good indication it might not be the best approach. Even if it works, if something goes wrong further ahead, you'll have few sources for support. Experimental features are usually not a good practise to release software to production.

Of my own case, I can say (as stated above) that it worked - but for some reason, later I came across one or two places where it didn't. Meaning, there were some unexpected exceptions that seemed hard to predict. I found myself having to specifically call connectMongo() in one or two places anyway, even if the initial connectMongo() in instrumentation worked.

This raised alarm bells to me, and for this reason I went back to the standard method of calling connectMongo() at the start of every method that made calls to mongo. I didn't have any unexpected errors after that.

It was good to experiment with instrumentation to get to know the experimental feature - but it is always best (safer) practice to stick with the standards.

Note that the typical connectMongo() call isn't actually calling mongo every time, but only the first time, because it caches the connection in the first call. The fact that we make sure to run connectMongo() every time does insure for every DB call that you will indeed have established a connection. Something that if instrumentation for some reason fails to establish at first run, no other place on your code will try to establish it again.

Coming from a mindset of more traditional Node.js apps, it may feel odd to call connectMongo() every time, but if you think about it, it is more fitting of the Next.js paradigm - where unlike classic single-js-bundle React apps, there is true code splitting and a route is rendered without caring about the rest of the app code.

Note that you don't need to call connectMongo() before every request to mongo. You only need to call it once for every method that will call mongo, be it once or multiple times:

// connect to database (or just return the previously cached connection)
await connectMongoDB()
// first call - get customer
const customer = await Customer.findById(customerId)
// second call - get customer documents
const documents = await Documents.find({
  customer_id: customerId,
})

My recommendation is for every route (where you have a page.tsx), create a dedicated actions.ts with "use server" at the top, place your server calls there, with a connectMongo() at the top of each method (using try / catch). This lets your application "sleep" and safely reawaken when a route is visited again, in serverless architectures. This will make your server calls happen safely server-side and let your client invoke them without the need for API routes.

[tikiram]

😲 Thanks for all the information, I'll consider your findings. I think the key takeaway here is the concept of serverless architectures , thanks again