How do I use Mongoose & MonogoDB with Next-Auth

[Tosinkoa]

Question 💬

Pls I would like someone to help me out with how to connect Mongoose and MongoDB with Next-Auth

How to reproduce ☕️

`// This approach is taken from https://github.com/vercel/next.js/tree/canary/examples/with-mongodb
import { MongoClient } from "mongodb"

const uri = process.env.MONGODB_URI
const options = {
useUnifiedTopology: true,
useNewUrlParser: true,
}

let client
let clientPromise

if (!process.env.MONGODB_URI) {
throw new Error("Please add your Mongo URI to .env.local")
}

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).
if (!global._mongoClientPromise) {
client = new MongoClient(uri, options)
global._mongoClientPromise = client.connect()
}
clientPromise = global._mongoClientPromise
} else {
// In production mode, it's best to not use a global variable.
client = new MongoClient(uri, options)
clientPromise = client.connect()
}

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

Contributing 🙌🏽

No, I am afraid I cannot help regarding this

[AdaptingAFM]

nextauthjs/adapters#355 (comment)

[tinkit2004]

1. Use the MongoDB Adaptor suggested in the documentation.

import { MongoClient } from "mongodb";

const uri = process.env.MONGODB_URI;
const options = {
  useUnifiedTopology: true,
  useNewUrlParser: true,
};

let client;
let clientPromise;

if (!process.env.MONGODB_URI) {
  throw new Error("Please add your Mongo URI to .env.local");
}

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).
  if (!global._mongoClientPromise) {
    client = new MongoClient(uri, options);
    global._mongoClientPromise = client.connect();
  }
  clientPromise = global._mongoClientPromise;
} else {
  // In production mode, it's best to not use a global variable.
  client = new MongoClient(uri, options);
  clientPromise = client.connect();
}

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

2. Create a new file called dbConnect.js with the following code

const MONGODB_URI = process.env.MONGODB_URI

if (!MONGODB_URI) {
  throw new Error(
    'Please define the MONGODB_URI environment variable inside .env.local'
  )
}

/**
 * Global is used here to maintain a cached connection across hot reloads
 * in development. This prevents connections growing exponentially
 * during API Route usage.
 */
let cached = global.mongoose

if (!cached) {
  cached = global.mongoose = { conn: null, promise: null }
}

async function dbConnect() {
  if (cached.conn) {
    return cached.conn
  }

  if (!cached.promise) {
    const opts = {
      bufferCommands: false,
    }

    cached.promise = mongoose.connect(MONGODB_URI, opts).then((mongoose) => {
      return mongoose
    })
  }
  cached.conn = await cached.promise
  return cached.conn
}

export default dbConnect```
3. Copy the user schema described in the documentation
```import mongoose from "mongoose";
const { Schema } = mongoose;
const userSchema = new Schema({
  name: String,
  email: String,
  emailVerified: Date,
  image: String,
});
userSchema.add({ lastName: String, password: String });
export default mongoose.models.User || mongoose.model("User", userSchema);

4. In your API route, you should use the mongoose in the following way

import dbConnect from "../../lib/dbConnect";

const bcrypt = require("bcrypt");
export default async function handler(req, res) {
  const { email, password } = req.body;
  await dbConnect();
  const { method } = req;
  switch (method) {
    case "POST":
      try {
        // Check if user input email and password
        if (!email || !password) {
          return res.status(400).json({ success: false, error: "empty" });
        }
        const foundUser = await User.findOne({ email: email }).exec();
        // Check if any user found
        if (foundUser) {
          const match = await bcrypt.compare(password, foundUser.password);
          if (match) {
            return res.status(200).json({
              success: true,
              _id: foundUser._id,
              name: foundUser.name,
              image: foundUser.image,
              email: foundUser.email,
            });
          } else {
            return res
              .status(400)
              .json({ success: false, error: "Wrong credential" });
          }
        }
        return res.status(400).json({ success: false, error: "No user found" });
      } catch (error) {
        console.log(error);
        return res.status(400).send(error);
      }

    default:
      return res.status(400).send("No such API route");
  }
}```