import model in next js 13 middleware

[ghost]

I'm using Next.js 13 and I have a User model in my application.

for user authentication, I should import my User model in middleware.js file.

when I import a model in middleware, this error happen.

TypeError: Cannot read properties of undefined (reading 'User')

how can I solve it?

Thank's

[hyjoong]

Could you provide more details on how the code responsible for checking User is structured? It's important to note that middleware runs on the server-side, so it cannot access client-side storage like local storage or session storage.

It seems that the code related to User might be designed for server-side logic, rather than being accessible on the server and client sides for interactions like cookies. Can you share more about how you've organized this logic on the server?

If you're trying to implement logic to redirect based on the user's login status, you can consider using cookies to determine whether the user is authenticated. Next.js provides a convenient way to work with cookies, and you can refer to the documentation for more details: Using Cookies in Next.js.

[ghost]

I just want import a model in middleware.js file. all of my auth system is ok. I have no problem with cookies. just this import remained.

and model is this

`import mongoose from "mongoose";

const UserSchema=new mongoose.Schema({
blog_name:{
type:String,
required:true,
},
username:{
type:String,
required:true,
},
});

export default mongoose.models.User || mongoose.model("User",UserSchema);`

[EliotCampbell]

Same problem. Error in middleware.js. When I remove User import, the error goes away.

`import { NextResponse } from 'next/server'
import { verifyJwt } from '@/utils'
import { User } from '@/models/models'

export const middleware = async (request) => {

if (request.nextUrl.pathname.startsWith('/api' && request.method !== 'GET')) {

try {
  const token = request.cookies.get('token').value
  if (!token) {
    return NextResponse.json({
      ok: false,
      message: 'Not auth or invalid token',
      dataObject: {}
    })
  }

  const payload = await verifyJwt(token)
  const email = payload.email
  const user = await User.findOne({ where: { email } })

  if (!user)
    return NextResponse.json({
      ok: false,
      message: 'User not found',
      dataObject: { email }
    })

  if (user.role !== 'ADMIN') {
    return NextResponse.json({
      ok: false,
      message: 'You are not ADMIN',
      dataObject: {}
    })
  }
  return NextResponse.next()
} catch (e) {
  return NextResponse.json({
    ok: false,
    message: 'Check role middleware error',
    dataObject: { error: e }
  })
}

}
return NextResponse.next()
}
`

I get an error:

• error node_modules\sequelize\lib\utils\deprecations.js (34:0) @
• error (0 , import_util.deprecate) is not a function

[mernfa]

solution is this

you can create a API.
then send user id from middleware to that api
in the api find user with this id

and in the middleware, you can request to that api

[erbhuwan]

Hey do you get the solution of the problem above????

[mernfa]

you can make another api for checking user testing.
and in the middleware you can request to that api and check it

[SAMUEL-UME]

``> you can make another api for checking user testing. and in the middleware you can request to that api and check it

Thanks alot for this .

/api/authenticate

`export default async function POST(request: NextRequest) {
await connect();

const { token } = await request.json();

if (!token) return new NextResponse("User not authorized", { status: 401 });
const decodedToken: any = await verifyToken(token, JWT_SECRET);
const user = await User.findById(decodedToken.id);

if (!user) return new NextResponse("User not authorized", { status: 401 });

return new NextResponse(JSON.stringify({ message: "Authorized", user }), {
	status: 200,
});

}`

Then for my middleware
`async function authenticateToken(request: NextRequest) {
const token = request.headers.get("authorization")?.split(" ")[1];

if (!token) return new NextResponse("Not authorized", { status: 401 });

const response = await fetch(
	new URL("/api/authenticate", request.url).toString(),
	{
		method: "POST",
		headers: { "Content-Type": "application/json" },
		body: JSON.stringify({ token }),
	}
);

if (response.status !== 200) return new NextResponse("Not authorized", { status: 401 });


return NextResponse.next();

}`

[shalomprasannan]

Fix > Optional Chaining.. > mongoose?.models?.model