Role-based access patterns in NextJS - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if the user has the 'admin' role.

NextJS

if (user.roles.includes([1])) {
  return <AdminPanel />;
} else {
  return <AccessDenied />;
}

Drag options to blanks, or click blank then click option'

A'user'

B'guest'

C'admin'

D'moderator'

Attempts:

3 left

💡 Hint

Common Mistakes

Using a role that does not exist in the roles array.

Forgetting to use quotes around the role string.

The code checks if the user's roles include the string 'admin'. This is the correct role to allow admin access.

2fill in blank

medium

Complete the code to redirect users without the 'editor' role to the home page.

NextJS

if (!user.roles.includes([1])) {
  router.push('/');
}

Drag options to blanks, or click blank then click option'

A'admin'

B'guest'

C'viewer'

D'editor'

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong role string.

Missing the negation operator (!) before includes.

The code redirects users who do not have the 'editor' role. So the blank must be 'editor'.

3fill in blank

hard

Fix the error in the code that checks if the user has any role from a list.

NextJS

const hasAccess = roles.some(role => user.roles.[1](role));

Drag options to blanks, or click blank then click option'

Afind

Bincludes

Cfilter

Dmap

Attempts:

3 left

💡 Hint

Common Mistakes

Using find() which returns an element or undefined, not a boolean.

Using map() which transforms arrays but does not check membership.

The includes() method checks if the user's roles array contains the current role. This is the correct method to use here.

4fill in blank

hard

Fill both blanks to create a higher-order component that restricts access based on roles.

NextJS

function withRole(Component, [1]) {
  return function Wrapped(props) {
    const user = useUser();
    if (!user.roles.[2](role => [1].includes(role))) {
      return <AccessDenied />;
    }
    return <Component {...props} />;
  };
}

Drag options to blanks, or click blank then click option'

AallowedRoles

Bsome

Cfilter

Devery

Attempts:

3 left

💡 Hint

Common Mistakes

Using every() instead of some(), which requires all roles to match.

Using filter() which returns an array, not a boolean.

The first blank is the parameter name for allowed roles. The second blank is the array method some(), which checks if any user role is in allowedRoles.

5fill in blank

hard

Fill all three blanks to implement server-side role check in Next.js getServerSideProps.

NextJS

export async function getServerSideProps(context) {
  const session = await getSession(context);
  if (!session || !session.user.roles.[1](role => role === [2])) {
    return {
      redirect: {
        destination: [3],
        permanent: false,
      },
    };
  }
  return { props: {} };
}

Drag options to blanks, or click blank then click option'

Asome

B'admin'

C'/login'

Devery

Attempts:

3 left

💡 Hint

Common Mistakes

Using every() which requires all roles to be 'admin'.

Redirecting to the wrong path.

The some() method checks if the user has the 'admin' role. If not, the user is redirected to '/login'.

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()