Role-based access patterns in NextJS - Step-by-Step Execution

Concept Flow - Role-based access patterns

User Requests Page

↓

Check User Role

↓

Allow Admin

↓

Render Page

This flow shows how a Next.js app checks a user's role before allowing access to a page or redirecting them.

Execution Sample

NextJS

import { NextResponse } from 'next/server';

export function middleware(req) {
  const role = req.cookies.get('role')?.value || 'guest';
  if (role === 'admin') return NextResponse.next();
  return NextResponse.redirect(new URL('/login', req.url));
}

Middleware checks the user's role from cookies and allows or blocks access accordingly.

Execution Table

Step	Action	Role Value	Condition Checked	Result	Next Step
1	Read 'role' cookie	admin	role === 'admin'	True	Allow access
2	Allow access	admin	-	Access granted	Render page
3	User requests page	user	role === 'admin'	False	Redirect to /login
4	Redirect to /login	user	-	Access denied	Show login page
5	User requests page	guest	role === 'admin'	False	Redirect to /login
6	Redirect to /login	guest	-	Access denied	Show login page

💡 Execution stops after allowing access or redirecting based on role check.

Variable Tracker

Variable	Start	After Step 1	After Step 3	After Step 5
role	undefined	admin	user	guest

Key Moments - 2 Insights

Why does the middleware redirect users who are not 'admin'?

Because the condition 'role === "admin"' is false for other roles, so the code redirects them to '/login' as shown in execution_table rows 3 and 5.

What happens if the 'role' cookie is missing?

The code assigns 'guest' as default role (see code line with '|| "guest"'), so the user is treated as guest and redirected, as in execution_table row 5.

Visual Quiz - 3 Questions

Look at the execution table, what is the role value at Step 3?

A admin

B user

C guest

D undefined

💡 Hint

Check the 'Role Value' column in execution_table row for Step 3.

At which step does the middleware allow access to the page?

A Step 1

B Step 4

C Step 2

D Step 6

💡 Hint

Look for 'Access granted' in the 'Result' column of execution_table.

If the role cookie was 'admin', what would happen at Step 5?

A Allow access

B Redirect to /login

C Show error message

D Role becomes guest

💡 Hint

Refer to how 'admin' role is handled in execution_table rows 1 and 2.

Concept Snapshot

Role-based access in Next.js uses middleware to check user roles.
It reads the role from cookies or defaults to 'guest'.
If role matches allowed roles (e.g., 'admin'), access is granted.
Otherwise, user is redirected to login or error page.
This pattern protects pages based on user permissions.

Full Transcript

This visual execution trace shows how role-based access works in Next.js using middleware. When a user requests a page, the middleware reads the 'role' cookie. If the role is 'admin', the middleware allows access and the page renders. If the role is anything else or missing, the middleware redirects the user to the login page. Variables like 'role' change based on cookie values. Key moments include understanding why non-admin users are redirected and what happens if the role cookie is missing. The quiz questions help reinforce these points by referencing specific steps in the execution table.

Practice

1. What is the main purpose of role-based access control in a Next.js application?

easy

A. To improve the app's loading speed by caching user data

B. To restrict or allow users to see or perform actions based on their assigned roles

C. To style components differently for each user

D. To automatically generate user profiles

Solution

1. Step 1: Understand role-based access control concept

   Role-based access control means controlling what users can do or see based on their roles.

2. Step 2: Identify the purpose in Next.js apps

   In Next.js, this means showing or hiding parts of the app depending on user roles to protect sensitive data.

3. Final Answer:

   To restrict or allow users to see or perform actions based on their assigned roles -> Option B

4. Quick Check:

   Role-based access controls user permissions = B [OK]

Hint: Role-based access controls user permissions and visibility [OK]

Common Mistakes:

• Confusing access control with styling or caching
• Thinking it automatically creates user profiles
• Assuming it improves app speed

2. Which of the following is the correct way to check a user's role in a Next.js component using session data?

easy

A. if (session.user.role === 'admin') { /* allow access */ }

B. if (user.role == 'admin') { /* allow access */ }

C. if (session.role === 'admin') { /* allow access */ }

D. if (session.user.roles.includes('admin')) { /* allow access */ }

Solution

1. Step 1: Identify session structure in Next.js

   Session data usually stores user info under session.user, including role as session.user.role.

2. Step 2: Check correct syntax for role comparison

   The correct check is session.user.role === 'admin' to compare role string exactly.

3. Final Answer:

   if (session.user.role === 'admin') { /* allow access */ } -> Option A

4. Quick Check:

   Use session.user.role for role check = C [OK]

Hint: Access role via session.user.role for correct check [OK]

Common Mistakes:

• Using user.role without session prefix
• Checking session.role directly (wrong path)
• Using == instead of === for strict comparison
• Assuming roles is an array when it's a string

3. Given this Next.js code snippet, what will be rendered if the user role is 'editor'?

function Dashboard({ session }) {
  if (session.user.role === 'admin') {
    return <div>Admin Panel</div>;
  } else if (session.user.role === 'editor') {
    return <div>Editor Workspace</div>;
  } else {
    return <div>Access Denied</div>;
  }
}

medium

A. Nothing will render due to error

B. <div>Admin Panel</div>

C. <div>Access Denied</div>

D. <div>Editor Workspace</div>

Solution

1. Step 1: Check user role conditionals

   The code checks if role is 'admin', then 'editor', else denies access.

2. Step 2: Match role 'editor' to conditional

   Since role is 'editor', the second condition matches and returns <div>Editor Workspace</div>.

3. Final Answer:

   <div>Editor Workspace</div> -> Option D

4. Quick Check:

   Role 'editor' matches editor condition = A [OK]

Hint: Match user role to if-else branches to find output [OK]

Common Mistakes:

• Choosing admin panel for editor role
• Assuming access denied for editor
• Thinking code has syntax errors

4. Identify the error in this Next.js role check code snippet:

function Page({ session }) {
  if (session.user.role = 'admin') {
    return <div>Admin Access</div>;
  }
  return <div>No Access</div>;
}

medium

A. session.user.role should be session.role

B. Missing else block after if statement

C. Using single equals (=) instead of triple equals (===) for comparison

D. Return statements are not allowed inside if

Solution

1. Step 1: Check the if condition syntax

   The code uses single equals (=) which assigns value instead of comparing.

2. Step 2: Identify correct comparison operator

   For comparison, triple equals (===) should be used to check equality without assignment.

3. Final Answer:

   Using single equals (=) instead of triple equals (===) for comparison -> Option C

4. Quick Check:

   Use === for comparison, not = [OK]

Hint: Use === for comparison, not = assignment [OK]

Common Mistakes:

• Confusing assignment (=) with comparison (===)
• Thinking else block is mandatory
• Incorrect session property path assumptions
• Believing return inside if is invalid

5. You want to protect a Next.js API route so only users with role 'admin' or 'manager' can access it. Which code snippet correctly implements this role-based access check?

hard

A. if (['admin', 'manager'].includes(session.user.role)) { /* allow */ } else { /* deny */ }

B. if (session.user.role === ['admin', 'manager']) { /* allow */ } else { /* deny */ }

C. if (session.user.role == 'admin' && session.user.role == 'manager') { /* allow */ } else { /* deny */ }

D. if (session.user.role === 'admin' && session.user.role === 'manager') { /* allow */ } else { /* deny */ }

Solution

1. Step 1: Understand role check for multiple roles

   We want to allow access if role is either 'admin' or 'manager'.

2. Step 2: Evaluate each option's logic

   if (session.user.role === 'admin' && session.user.role === 'manager') { /* allow */ } else { /* deny */ } uses && which requires the role to be both simultaneously (impossible); if (session.user.role === ['admin', 'manager']) { /* allow */ } else { /* deny */ } compares role to array directly (wrong); if (['admin', 'manager'].includes(session.user.role)) { /* allow */ } else { /* deny */ } uses includes() on array which is clean and correct; if (session.user.role == 'admin' && session.user.role == 'manager') { /* allow */ } else { /* deny */ } uses && which requires role to be both roles simultaneously (impossible).

3. Final Answer:

   if (['admin', 'manager'].includes(session.user.role)) { /* allow */ } else { /* deny */ } -> Option A

4. Quick Check:

   Use includes() to check multiple roles = D [OK]

Hint: Use array.includes(role) to check multiple roles easily [OK]

Common Mistakes:

• Comparing role directly to an array
• Using && instead of || for multiple roles
• Not using includes() for clean checks
• Assuming || is always better than includes()