Skjermbilde som viser brukeradmin-dashbord for nettsidene til Boligsameiet Gartnerihagen.

Brukeradmin-panel med Gatsby Functions og Auth0

I en serie med artikler har jeg vist hvordan jeg lagde nye nettsider til sameiet ved hjelp av React-rammeverket Gatsby og med brukerautentisering via Auth0. Les del 1 her: Slik bygget jeg nye nettsider til sameiet med Gatsby og Chakra UI

Da de nye nettsidene ble lansert, foregikk all administrasjon av brukere via et temmelig teknisk og innviklet brukergrensesnitt hos Auth0. For at nettsidene til sameiet skal bli en fullverdig løsning som kan overleveres andre etter at jeg går av som styreleder neste år, trengs det imidlertid et mer brukervennlig dashbord som gjør at selv ikke-tekniske brukere kan opprette, oppdatere eller slette brukere.

Min løsning er bygget opp slik:

  • Gatsby på frontend til å lage brukeradmin-dashbordet. Til dashbordet bruker jeg det som kalles client only routes i Gatsby, som jeg har skrevet om her.
  • Auth0 Authentication API for autentisering av brukeren på frontend. Her bruker jeg Auth0 React SDK for Single Page Apps for å gjøre ting litt enklere for meg selv.
  • Gatsby Functions (serverless functions) på backend. Dette er Node-applikasjoner som kjører på serveren og som tar kontakt med Auth0 Management API for å opprette, oppdatere eller slette brukere.

Du finner all kildekoden til hele løsningen på https://github.com/klekanger/gartnerihagen, men i denne artikkelen går jeg gjennom hvordan den er bygget opp — uten at jeg går i detaljer på alt (det ville blitt en bok!).

Hvordan sikre løsningen

Alt som gjøres på klienten kan i utgangspunktet manipuleres. Brukeradministrasjon krever høy sikkerhet, og det å sjekke at noen har tillatelse til å opprette, slette eller oppdatere brukere bør derfor gjøres på en server — ikke på klienten.

Gangen i det hele er som følger:

  • Brukeren logger inn på klienten og mottar et access token fra Auth0
  • Når brukeren besøker brukeradmin-dashbordet, sendes access-tokenet til en serverless function hos Netlify som 1) sjekker at det er et gyldig access token, 2) tar kontakt med Auth0 og sjekker at access-tokenet tilhører en bruker med de nødvendige rettighetene til å gjøre hva det nå måtte være som skal gjøres fra brukeradmin-dashbordet
  • Hvis brukeren har de nødvendige rettighetene tar serverless-funksjonen kontakt med Auth0 sitt Management API som returnerer en oversikt over alle brukerne.

For å få tilgang til brukeradmin-dashbordet i min løsning, må brukeren ha rollen "admin". Jeg bruker Auth0 sin løsning for rollebasert aksesskontroll (RBAC) til å definere tre ulike roller: "user", "editor" og "admin". Avhengig av rolle, vil den innloggede brukeren få opp knapper for brukeradministrasjon og/eller redigering av innhold når vedkommende går inn på "Min side" på sameiets nettsider:

Når brukeren besøker "Min side" vil det dukke opp knapper for å gå til brukeradministrasjon eller redigering av innhold hvis brukeren har de riktige rollene.
Når brukeren besøker "Min side" vil det dukke opp knapper for å gå til brukeradministrasjon eller redigering av innhold hvis brukeren har de riktige rollene.

Her er en forenklet skisse av hvordan det fungerer:

Skisse som viser hvordan frontenden mottar et access token fra Auth0. Dette access-tokenet brukes så av vår Gatsby Function for å verifisere at brukeren har nødvendige tilganger for å administrere brukere.

Gatsby Functions gjør det enkelt å lage API-er

Da jeg startet prosjektet med å lage brukeradmin-dashbordet, begynte jeg å lage API-ene for å hente, oppdatere eller opprette brukere med Netlify Functions. Jeg var godt igang med dette, da Gatsby annonserte at de hadde lansert Gatsby Functions. Plutselig hadde Gatsby innebygget støtte for serverless functions, og jobben min ble enda enklere. Dette er noe Next.js har hatt lenge, så velkommen etter, Gatsby!

Å opprette en Gatsby Function er så enkelt som å opprette en JavaScript- eller TypeScript-fil i mappen src/api/ og eksportere en handler-funksjon som tar to parametere — req (request) og res (response). For de som har vært borti Node-rammeverket Express, er Gatsby Functions temmelig likt.

Hello World-eksempelet i Gatsbys offisielle dokumentasjon illustrerer hvor enkelt det kan gjøres:

// src/api/hello-world.js

export default function handler(req, res) {
  res.status(200).json({ hello: `world` })
}

Gjør du et kall til URL-en /api/hello-world returnerer serverless-funksjonen { hello: 'world' }, og HTTP-statuskode 200 (som betyr at alt er i orden).

Fire API-er

Jeg fant ut at jeg trengte fire API-er. Hvert API er én serverless-funksjon:

src
├── api
│   └── admin-users
│       ├── create-user.ts
│       ├── delete-user.ts
│       ├── get-users-in-role.ts
        └── update-user.ts

Når brukere besøker brukeradmin-nettsiden (som de får tilgang til via "Min side" kalles API-et get-users-in-role. Forutsatt at den innloggede brukeren har rettighetene i orden, returnerer API-et en liste over samtlige brukere, inkludert rollene til hver av brukerne. Hver bruker vises som et kort på brukeradmin-dashbordet, med knapper for å endre bruker, slette bruker eller bytte passord for brukeren:

Skjermbilde av brukeradmin-grensesnittet.
Søkefeltet og dropdown-menyen lar deg filtrere ut kun de brukerne du er interessert i.

Gjøre klart ting hos Auth0

Det var ganske mye som måtte skrus sammen for å få hele maskineriet til å fungere som det skulle. Før jeg kunne lage mine egne backend-API-er med Gatsby Functions for administrasjon av brukere måtte jeg sette opp en del ting hos Auth0 først.

Først måtte jeg opprette en ny såkalt "maskin-til-maskin"-applikasjon hos Auth0. Dette er applikasjoner som ikke skal kommunisere med klienter, kun med en annen server du stoler på (som serverless-funksjonene jeg ville lage for brukeradministrasjon).

Når jeg logger meg inn på manage.auth0.com og går inn på Applications finner jeg disse to applikasjonene:

Skjermbilde som viser to applikasjoner hos Auth0: Backend og Boligsameiet Gartnerihagen.

Den som heter Boligsameiet Gartnerihagen er den som tar seg av den vanlige autentiseringen for brukere som er logget inn på nettsiden. Den som heter Backend er maskin-til-maskin-applikasjonen som skal brukes av vår serverless Gatsby-funksjon som kjører på serverne til Netlify.

For å få satt opp rollebaserte tillatelser (RBAC) må vi opprette et nytt API hos Auth0 hvor vi legger inn alle tillatelsene (scopes) vi skal kunne gi brukere basert på hvilke roller brukeren har. Dette er tillatelsene Auth0s Management API krever for å kunne utføre ulike operasjoner, og som vi senere kan velge blant når vi oppretter de ulike rollene for brukerne (i vårt tilfelle admin, user eller editor).

Jeg kalte mitt API for Useradmin, og la inn de ulike tillatelsene jeg kom til å trenge for oppdatering av brukere og roller. Auth0 har en nærmere beskrivelse av gangen i det hele her.

Skjermbilde som viser API-er hos Auth0, og hvordan vi har definert tillatelser for API-et Useradmin.

Når dette var gjort, ga jeg maskin-til-maskin-applikasjonen Backend tilgang til både Auth0 sitt Management API og det nye Useradmin-API-et jeg nettopp lagde.

Skjermbilde som viser Auth0 Backend-applikasjonen som har fått tilgang til Auth0 Management API og Useradmin API.

Dette er imidlertid ikke nok — i tillegg må du trykke den lille nedoverpilen lengst til høyre på hvert av API-ene (Auth0 Management API og Useradmin) for å gi Backend-applikasjonen de nødvendige tillatelsene for hvert API. Jeg huket av alle rettighetene som jeg hadde definert for Useradmin-API-et.

Skjermbilde: Vi har krysset av i sjekkboksene for alle tillatelsene Backend-applikasjonen skal ha tilgang til.

Deretter måtte jeg sette opp de ulike bruker-rollene ved å velge User Management fra hovedmenyen hos Auth0 og så velge Roles. Jeg opprettet de tre rollene, admin, editor og user, og for hver av rollene valgte jeg Add permissions, deretter hvilket API jeg ville legge til tillatelser fra — i mitt tilfelle Useradmin.

Skjermbilde: Vi har definert tre roller hos Auth0: Admin, user og editor.

For Admin-rollen la jeg til samtlige tillatelser som var definert i Useradmin-API-et. Rollene editor og user trengte ingen tillatelser — dette er roller jeg kun sjekker for på klienten for å avgjøre om hvorvidt knapper for å redigere innhold på nettsiden skal vises eller ikke. Brukere som har admin-rollen er de eneste som vil få tillatelse av Gatsby-funksjonen jeg har laget til å ta kontakt med Auth0 Management API (som igjen vil sjekke at brukeren faktisk har de nødvendige tillatelsene).

Skjermbilde: Admin-rollen har fått alle tillatelsene.

For å slippe unødvendige API-kall og forenkle koden på klientsiden, ønsket jeg også å gjøre det mulig å se hvilke roller en bruker har når brukeren logger seg inn. Dette for å kunne vise roller på Min side, i tillegg til å vise knapper for brukeradministrasjon og innholdsredigering kun for de som har riktige roller. Som standard vil access-tokenet kun inneholde alle tillatelsene brukeren har fått (gjennom sin rolle), men navnet på rollen vil ikke ligge i metadataene i access-tokenet. Det må vi fikse.

Auth0 har noe som kalles Flows og Actions som gjør det mulig å gjøre ulike ting for eksempel i forbindelse med innlogging, brukerregistrering eller annet. Jeg valgte den "flowen" som heter Login, og valgte deretter å legge til en "action" som skal komme etter at brukeren logger seg inn og før access-tokenet er sendt.

Når du oppretter en ny action hos Auth0 får du opp en kodeeditor. Jeg la inn følgende kodesnutt, som sørger for å legge til alle rollene til brukeren i access-tokenet som sendes til klienten:

/**
 * @param {Event} event - Details about the user and the context in which they are logging in.
 * @param {PostLoginAPI} api - Interface whose methods can be used to change the behavior of the login.
 */
exports.onExecutePostLogin = async (event, api) => {
  const namespace = 'https:/gartnerihagen-askim.no';
  if (event.authorization) {
    api.idToken.setCustomClaim(`${namespace}/roles`, event.authorization.roles);
    api.accessToken.setCustomClaim(`${namespace}/roles`, event.authorization.roles);
  }
}

Beskrivelse av dette, og flere eksempler på hva actions kan brukes til finner du hos Auth0, koden over er hentet herfra.

Hent en liste over alle brukere

Omsider kan vi begynne å lage brukeradmin-dashbordet som skal kjøre på klienten. Vi starter med hovedsiden, den som viser alle registrerte brukere. Komponentene for å redigere brukere og slette brukere skal jeg gå gjennom i neste artikkel.

På frontenden opprettet jeg komponenten userAdminPage.tsx som returnerer brukergrensesnittet med en boks øverst med informasjon om hvem som er logget inn, et tekstfelt for å filtrere/søke etter brukere, samt en dropdown-meny for å velge om man ønsker å vise alle brukere eller kun administratorer eller redaktører. Dette var ganske rett frem å lage, takket være ferdige komponenter i Chakra UI.

Jeg lagde så en custom hook (useGetAllUsers.js) som tar kontakt med get-users-in-role-API-et og sender med access-tokenet til den innloggede brukeren. Custom-hooken returnerer variablene data, loading og error, samt funksjonen getToken som brukes hvis Auth0 trenger den innloggede brukerens tillatelse til at Auth0 kan aksessere brukerkontoen. Dette er noe nye brukere vil bli spurt om første gang.

Hvis loading = true viser jeg min egen custom LoadingSpinner-komponent med en melding til brukeren.

const { data, loading, error, getToken } = useGetAllUsers();

if (loading) {
  return (
    <LoadingSpinner spinnerMessage='Kobler til brukerkonto-administrasjon' />
  );
}

Så snart get-users-in-role-API-et er ferdig med å hente alle brukerne, finner vi alle brukerne i data.body.users og jeg bruker array-metoden .filter til å filtrere ut kun de brukerne jeg vil vise (basert på hva jeg har tastet inn i søkefeltet). Og så sorteres alle navnene med .sort før jeg løper over dem med .map og presenterer brukerne som hvert sitt kort på skjermen.

Før vi kommer så langt, har det imidlertid skjedd litt backend-magi i Gatsby-funksjonen get-users-in-role. Først bruker vi biblioteket @serverless-jwt/jwt-verifier for å lese access-tokenet som klienten nettopp sendte da den gjorde en GET-request til get-users-in-role. Dette er altså access-tokenet til den brukeren som er logget inn på klienten. Etter å ha sjekket at det er et gyldig token med jwt.verifyAccessToken, henter vi ut hvilke tillatelser som ligger i dette tokenet, og sjekker at det er de tillatelsene som trengs. Hvilke tillatelser brukeren må ha for å utføre ulike operasjoner er godt beskrevet i dokumentasjonen til Auth0 sitt Management API og i dokumentasjonen til ManagementClient-SDK-et jeg bruker for å gjøre jobben enklere for meg selv.

Her er første del av koden til serverless-funksjonen, den del av koden som sjekker rettigheter etc.:

// api/admin-users/get-users-in-role.ts

import { GatsbyFunctionRequest, GatsbyFunctionResponse } from 'gatsby';
const ManagementClient = require('auth0').ManagementClient;
const {
  JwtVerifier,
  JwtVerifierError,
  getTokenFromHeader,
} = require('@serverless-jwt/jwt-verifier');

const jwt = new JwtVerifier({
  issuer: `https://${process.env.GATSBY_AUTH0_DOMAIN}/`,
  audience: `https://${process.env.AUTH0_USERADMIN_AUDIENCE}`,
});

export default async function handler(
  req: GatsbyFunctionRequest,
  res: GatsbyFunctionResponse
) {
  let claims, permissions
  const token = getTokenFromHeader(req.headers.authorization);

  if (req.method !== `GET`) {
    return res.status(405).json({
      error: 'method not allowed',
      error_description: 'You should do a GET request to access this',
    });
  }

  // Verify access token
  try {
    claims = await jwt.verifyAccessToken(token);
    permissions = claims.permissions || [];
  } catch (err) {
    if (err instanceof JwtVerifierError) {
      return res.status(403).json({
        error: `Something went wrong. ${err.code}`,
        error_description: `${err.message}`,
      });
    }
  }

  // check if user should have access at all
  if (!claims || !claims.scope) {
    return res.status(403).json({
      error: 'access denied',
      error_description: 'You do not have access to this',
    });
  }

  // Check the permissions
  if (!permissions.includes('read:roles')) {
    return res.status(403).json({
      error: 'no read access',
      status_code: res.statusCode,
      error_description:
        'Du må ha admin-tilgang for å administrere brukere. Ta kontakt med styret.',
      body: {
        data: [],
      },
    });
  }
.
.
.

Roller i Auth0 fungerer ved at du definerer de rollene du ønsker (i vårt tilfelle "user", "editor", "administrator"). Så definerer du hvilke rettigheter hver rolle skal ha. Til slutt tilegner du en eller flere roller til brukerne.

Tidligere lagret man roller i et eget app_metadata-felt i access-tokenet for hver bruker, men Auth0 har gått over til en ny løsning for rollebasert autentisering som gjør at vi ikke lenger får rollene levert sammen med dataene for hver enkelt bruker. Det gjorde jobben med å hente alle brukere og rollene for hver bruker, ganske mye mer tungvint. Jeg endte opp med å bygge følgende get-users-in-role-API:

  • Bruke Auth0 sitt ManagementClient-SDK til å opprette en ny ManagementClient som vi kaller auth0.
  • Nå som vi har en ManagementClient som heter auth0, kan vi bruke auth0.getRoles() for å hente alle tilgjengelige roller vi har definert hos Auth0. Vi får da et array med rollene user, admin og editor (vi kunne selvfølgelig hardkodet dette, men ved å bruke getRoles-metoden er løsningen fleksibel og vil fortsatt fungere hvis vi senere skulle finne på å opprette nye roller hos Auth0.
  • Vi bruker .map til å lage enda et nytt array som inneholder alle brukerne innenfor hver rolle. Det gjør vi med auth0.getUsersInRole der vi sender inn ID-en til hver av rollene vi hentet med getRoles.
  • Nå har vi et array som heter userRoles som inneholder alle de tre rollene, med alle brukerne innenfor hver rolle. Hvis en bruker har to roller (f.eks. er både editor og admin), vil brukeren finnes flere steder.
[
        {
            "role": "admin",
            "users": [
                {
                    "user_id": "auth0|xxx",
                    "email": "kurt@lekanger.no",
                    "name": "Kurt Lekanger"
                }
            ]
        },
        {
            "role": "editor",
            "users": [
                {
                    "user_id": "auth0|xxx",
                    "email": "kurt@lekanger.no",                    
                    "name": "Kurt Lekanger"
                },
                {
                    "user_id": "auth0|yyy",
                    "email": "kurt@testesen.xx",                    
                    "name": "Kurt Testesen"
                },
						]
				}
... og så videre!
]

Det vi er ute etter er imidlertid et array med alle brukerne, der hver bruker eksisterer bare én gang som et objekt som igjen inneholder et array med alle rollene i. Vi må derfor bygge opp et nytt array som jeg har kalt userListWithRoles. Først henter jeg samtlige brukere som er registrert i databasen hos Auth0 med const userList = await auth0.getUsers(). Så bruker jeg forEach med en nøstet for-loop inni for å gå over én og én bruker og sjekke én og én rolle og om brukeren eksisterer i brukerlisten for denne rollen. Hver rolle brukeren har, blir lagt inn i et roles-array for denne brukeren.

En skisse som illustrerer hvordan det fungerer, og hvilke metoder i ManagementClient-SDK-et som brukes:

Skisse som viser hvordan vi bygger opp et nytt array med brukere, der hver bruker har et array med alle rollene til brukeren.

Til slutt returnerer jeg userListWithRoles fra API-et og HTTP-statuskode 200 for å indikere at alt gikk som det skulle. Veldig forkortet eksempel på hva som returneres fra API-et — legg merke til at hver bruker nå har fått et roles-array:

  body: {
    users: [
      {
        name: 'Kurt Lekanger',
        email: "kurt@lekanger.no",
        user_id: 'auth0|xxxx',
        roles: ['admin', 'editor', 'user'],
      },
      {
        name: 'Kurt Testesen',
				email: "kurt@testesen.xx",
        user_id: 'auth0|yyyy',
        roles: ['editor', 'user'],
      },
    ],
  },

I virkeligheten inneholder hvert brukerobjekt i userListWithRoles-arrayet også en masse andre metadata fra Auth0, som bl.a. når brukeren var logget inn sist, epostadresse, om eposten er verifisert, osv.

Her er resten av kildekoden til get-users-in-role-API-et:

// // api/admin-users/get-users-in-role.ts 
.
.
.
  const auth0 = new ManagementClient({
    domain: `${process.env.GATSBY_AUTH0_DOMAIN}`,
    clientId: `${process.env.AUTH0_BACKEND_CLIENT_ID}`,
    clientSecret: `${process.env.AUTH0_BACKEND_CLIENT_SECRET}`,
    scope: 'read:users read:roles read:role_members',
  });

  try {
    const roles: string[] | undefined = await auth0.getRoles();
    const allUsersInRoles = await roles.map(async (role: any) => {
      const usersInRole = await auth0.getUsersInRole({ id: role.id });
      return { role: role.name, users: usersInRole };
    });

    const userRoles = await Promise.all(allUsersInRoles); // Get a list of all the roles and the users within each of them,
    const userList = await auth0.getUsers(); // and a list of every registered user

    let userListWithRoles = [];
    userList.forEach((user) => {
      for (let i = 0; i < userRoles.length; i++) {
        if (
          userRoles[i].users.find((element) => element.user_id === user.user_id)
        ) {
          const existingUserToModify = userListWithRoles.find(
            (element) => element.user_id === user.user_id
          );
          if (existingUserToModify) {
            existingUserToModify.roles = [
              ...existingUserToModify.roles,
              userRoles[i].role, 
            ];
          } else {
            userListWithRoles.push({
              ...user,
              roles: [userRoles[i].role],
            });
          }
        }
      }
    });

    res.status(200).json({
      body: {
        users: userListWithRoles,
      },
    });
  } catch (error) {
    res.status(error.statusCode || 500).json({
      body: {
        error: error.name,
        status_code: error.statusCode || 500,
        error_description: error.message,
      },
    });
  }
}

I neste artikkel skal jeg gå gjennom hvordan jeg lagde komponentene for å opprette, oppdatere eller slette brukere.

Les neste del: Brukeradmin-dashbord med Gatsby Functions: Oppdatere, opprette eller slette brukere

Du finner all kildekoden til hele løsningen på https://github.com/klekanger/gartnerihagen

Denne YouTube-videoen viser hvordan brukergrensesnittet og nettsidene ser ut live: https://youtu.be/XzkTRw5D5mg

Gå til forsiden