fix(adapter-mongodb): Improve MongoDB connection handling for serverless environments (#9459)

Co-authored-by: Nico Domino <[email protected]>

Author: simonecervini

packages/adapter-mongodb/src/index.ts

@@ -25,6 +25,16 @@ import type {
 } from "@auth/core/adapters"
 import type { MongoClient } from "mongodb"
 
+/**
+ * This adapter uses https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html#using-declarations-and-explicit-resource-management.
+ * This feature is very new and requires runtime polyfills for `Symbol.asyncDispose` in order to work properly in all environments.
+ * It is also required to set in the `tsconfig.json` file the compilation target to `es2022` or below and configure the `lib` option to include `esnext` or `esnext.disposable`.
+ *
+ * You can find more information about this feature and the polyfills in the link above.
+ */
+// @ts-expect-error read only property is not assignable
+Symbol.asyncDispose ??= Symbol("Symbol.asyncDispose")
+
 /** This is the interface of the MongoDB adapter options. */
 export interface MongoDBAdapterOptions {
   /**
@@ -40,6 +50,14 @@ export interface MongoDBAdapterOptions {
    * The name you want to give to the MongoDB database
    */
   databaseName?: string
+  /**
+   * Callback function for managing the closing of the MongoDB client.
+   * This could be useful in serverless environments, especially when `client`
+   * is provided as a function returning Promise<MongoClient>, not just a simple promise.
+   * It allows for more sophisticated management of database connections,
+   * addressing persistence, container reuse, and connection closure issues.
+   */
+  onClose?: (client: MongoClient) => Promise<void>
 }
 
 export const defaultCollections: Required<
@@ -89,83 +107,95 @@ export function _id(hex?: string) {
 }
 
 export function MongoDBAdapter(
-  client: Promise<MongoClient>,
+  /**
+   * The MongoDB client. You can either pass a promise that resolves to a `MongoClient` or a function that returns a promise that resolves to a `MongoClient`.
+   * Using a function that returns a `Promise<MongoClient>` could be useful in serverless environments, particularly when combined with `options.onClose`, to efficiently handle database connections and address challenges with persistence, container reuse, and connection closure.
+   * These functions enable either straightforward open-close database connections or more complex caching and connection reuse strategies.
+   */
+  client: Promise<MongoClient> | (() => Promise<MongoClient>),
   options: MongoDBAdapterOptions = {}
 ): Adapter {
   const { collections } = options
   const { from, to } = format
 
-  const db = (async () => {
-    const _db = (await client).db(options.databaseName)
+  const getDb = async () => {
+    const _client = await (typeof client === "function" ? client() : client)
+    const _db = _client.db(options.databaseName)
     const c = { ...defaultCollections, ...collections }
     return {
       U: _db.collection<AdapterUser>(c.Users),
       A: _db.collection<AdapterAccount>(c.Accounts),
       S: _db.collection<AdapterSession>(c.Sessions),
       V: _db.collection<VerificationToken>(c?.VerificationTokens),
+      [Symbol.asyncDispose]: async () => {
+        await options.onClose?.(_client)
+      },
     }
-  })()
+  }
 
   return {
     async createUser(data) {
       const user = to<AdapterUser>(data)
-      await (await db).U.insertOne(user)
+      await using db = await getDb()
+      await db.U.insertOne(user)
       return from<AdapterUser>(user)
     },
     async getUser(id) {
-      const user = await (await db).U.findOne({ _id: _id(id) })
+      await using db = await getDb()
+      const user = await db.U.findOne({ _id: _id(id) })
       if (!user) return null
       return from<AdapterUser>(user)
     },
     async getUserByEmail(email) {
-      const user = await (await db).U.findOne({ email })
+      await using db = await getDb()
+      const user = await db.U.findOne({ email })
       if (!user) return null
       return from<AdapterUser>(user)
     },
     async getUserByAccount(provider_providerAccountId) {
-      const account = await (await db).A.findOne(provider_providerAccountId)
+      await using db = await getDb()
+      const account = await db.A.findOne(provider_providerAccountId)
       if (!account) return null
-      const user = await (
-        await db
-      ).U.findOne({ _id: new ObjectId(account.userId) })
+      const user = await db.U.findOne({ _id: new ObjectId(account.userId) })
       if (!user) return null
       return from<AdapterUser>(user)
     },
     async updateUser(data) {
       const { _id, ...user } = to<AdapterUser>(data)
-
-      const result = await (
-        await db
-      ).U.findOneAndUpdate({ _id }, { $set: user }, { returnDocument: "after" })
+      await using db = await getDb()
+      const result = await db.U.findOneAndUpdate(
+        { _id },
+        { $set: user },
+        { returnDocument: "after" }
+      )
 
       return from<AdapterUser>(result!)
     },
     async deleteUser(id) {
       const userId = _id(id)
-      const m = await db
+      await using db = await getDb()
       await Promise.all([
-        m.A.deleteMany({ userId: userId as any }),
-        m.S.deleteMany({ userId: userId as any }),
-        m.U.deleteOne({ _id: userId }),
+        db.A.deleteMany({ userId: userId as any }),
+        db.S.deleteMany({ userId: userId as any }),
+        db.U.deleteOne({ _id: userId }),
       ])
     },
     linkAccount: async (data) => {
       const account = to<AdapterAccount>(data)
-      await (await db).A.insertOne(account)
+      await using db = await getDb()
+      await db.A.insertOne(account)
       return account
     },
     async unlinkAccount(provider_providerAccountId) {
-      const account = await (
-        await db
-      ).A.findOneAndDelete(provider_providerAccountId)
+      await using db = await getDb()
+      const account = await db.A.findOneAndDelete(provider_providerAccountId)
       return from<AdapterAccount>(account!)
     },
     async getSessionAndUser(sessionToken) {
-      const session = await (await db).S.findOne({ sessionToken })
+      await using db = await getDb()
+      const session = await db.S.findOne({ sessionToken })
       if (!session) return null
-      const user = await (
-        await db
-      ).U.findOne({ _id: new ObjectId(session.userId) })
+      const user = await db.U.findOne({ _id: new ObjectId(session.userId) })
       if (!user) return null
       return {
         user: from<AdapterUser>(user),
@@ -174,38 +204,35 @@ export function MongoDBAdapter(
     },
     async createSession(data) {
       const session = to<AdapterSession>(data)
-      await (await db).S.insertOne(session)
+      await using db = await getDb()
+      await db.S.insertOne(session)
       return from<AdapterSession>(session)
     },
     async updateSession(data) {
       const { _id, ...session } = to<AdapterSession>(data)
-
-      const updatedSession = await (
-        await db
-      ).S.findOneAndUpdate(
+      await using db = await getDb()
+      const updatedSession = await db.S.findOneAndUpdate(
         { sessionToken: session.sessionToken },
         { $set: session },
         { returnDocument: "after" }
       )
       return from<AdapterSession>(updatedSession!)
     },
     async deleteSession(sessionToken) {
-      const session = await (
-        await db
-      ).S.findOneAndDelete({
+      await using db = await getDb()
+      const session = await db.S.findOneAndDelete({
         sessionToken,
       })
       return from<AdapterSession>(session!)
     },
     async createVerificationToken(data) {
-      await (await db).V.insertOne(to(data))
+      await using db = await getDb()
+      await db.V.insertOne(to(data))
       return data
     },
     async useVerificationToken(identifier_token) {
-      const verificationToken = await (
-        await db
-      ).V.findOneAndDelete(identifier_token)
-
+      await using db = await getDb()
+      const verificationToken = await db.V.findOneAndDelete(identifier_token)
       if (!verificationToken) return null
       const { _id, ...rest } = verificationToken
       return rest

packages/adapter-mongodb/test/serverless.test.ts

@@ -0,0 +1,80 @@
+import { runBasicTests } from "utils/adapter"
+import { defaultCollections, format, MongoDBAdapter, _id } from "../src"
+import { MongoClient } from "mongodb"
+import { expect, test, vi } from "vitest"
+
+const name = "serverless-test"
+const clientPromise = new MongoClient(
+  `mongodb://localhost:27017/${name}`
+).connect()
+
+const onClose = vi.fn(async (client: MongoClient) => {
+  await client.close()
+})
+
+let mongoClientCount = 0
+
+runBasicTests({
+  adapter: MongoDBAdapter(
+    async () => {
+      const client = await new MongoClient(
+        `mongodb://localhost:27017/${name}`
+      ).connect()
+      mongoClientCount++
+      return client
+    },
+    {
+      onClose,
+    }
+  ),
+  db: {
+    async disconnect() {
+      const client = await clientPromise
+      await client.db().dropDatabase()
+      await client.close()
+    },
+    async user(id) {
+      const client = await clientPromise
+      const user = await client
+        .db()
+        .collection(defaultCollections.Users)
+        .findOne({ _id: _id(id) })
+
+      if (!user) return null
+      return format.from(user)
+    },
+    async account(provider_providerAccountId) {
+      const client = await clientPromise
+      const account = await client
+        .db()
+        .collection(defaultCollections.Accounts)
+        .findOne(provider_providerAccountId)
+      if (!account) return null
+      return format.from(account)
+    },
+    async session(sessionToken) {
+      const client = await clientPromise
+      const session = await client
+        .db()
+        .collection(defaultCollections.Sessions)
+        .findOne({ sessionToken })
+      if (!session) return null
+      return format.from(session)
+    },
+    async verificationToken(identifier_token) {
+      const client = await clientPromise
+      const token = await client
+        .db()
+        .collection(defaultCollections.VerificationTokens)
+        .findOne(identifier_token)
+      if (!token) return null
+      const { _id, ...rest } = token
+      return rest
+    },
+  },
+})
+
+test("all the connections are closed", () => {
+  expect(mongoClientCount).toBeGreaterThan(0)
+  expect(onClose).toHaveBeenCalledTimes(mongoClientCount)
+})