Laptop med VS Code på skjermen.

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

Dette er del 2 om hvordan jeg har laget et brukeradmin-dashbord med Auth0 og Gatsby Functions. Har du ikke allerede gjort det, bør du lese del 1 først. Få også gjerne med deg starten på hele prosjektet: Slik bygget jeg nye nettsider til sameiet med Gatsby og Chakra UI

I første del gikk jeg gjennom hvordan jeg bygget et brukeradmin-dashbord med Gatsby Functions, og hvordan det hele ble satt opp hos Auth0 for at jeg skulle kunne bruke rollebasert aksesskontroll og Auth0s Management API til å presentere en oversikt over alle som er registrert som brukere på sameiets nettsider.

Funksjonaliteten for å vise alle brukerne, inkludert hvilke roller de har (user, editor eller admin) er altså på plass. Det som gjenstår er det som skal skje når du trykker knappene for å opprette en ny bruker, oppdatere en bruker eller slette en bruker.

Opprette ny brukere

Når brukeren klikker knappen Opprett ny bruker, bruker jeg Gatsbys navigate-funksjon for å sende brukeren til /user-admin/create-user.

Skjermbilde som viser tittel "Brukeradministrasjon", søkefelt og en knapp for å opprette nye brukere.

Ruten /user-admin/ og alt under der er definert som en client only-rute i konfigurasjonen til pluginen gatsby-plugin-create-client-paths i filen gatsby-config.js, slik at det ikke lages statiske sider når Gatsby-prosjektet bygges. Under /src/pages har jeg opprettet filen user-admin.tsx som inneholder den nødvendige koden for å rute brukerne til sidene for å henholdsvis opprette brukere, oppdatere brukere, eller gå til hovedsiden for brukeradministrasjon.<Privateroute>-komponenten i kodesnutten under bruker en higher order-komponent i auth0-react kalt withAutenthicationRequired til å sjekke om en bruker er logget inn eller ikke.

// src/pages/user-admin.tsx

import * as React from 'react';
import { useAuth0 } from '@auth0/auth0-react';
import { Router } from '@reach/router';
import PrivateRoute from '../utils/privateRoute';
import NotLoggedIn from '../components/notLoggedIn';
import LoadingSpinner from '../components/loading-spinner';
import UserAdminPage from '../components/private-components/user-admin/userAdminPage';
import CreateUserPage from '../components/private-components/user-admin/createUserPage';
import UpdateUserPage from '../components/private-components/user-admin/updateUserPage';

function UserAdmin() {
  const { isLoading, isAuthenticated, error } = useAuth0();

  if (isLoading) {
    return <LoadingSpinner />;
  }

  if (error) {
    return <div>Det har oppstått en feil... {error.message}</div>;
  }

  if (!isAuthenticated) {
    return (
      <NotLoggedIn
        title='Logg inn for brukeradministrasjon'
        description='Du må logge inn for å administrere brukerkontoer for Boligsameiet Gartnerihagen. 
      Du vil da kunne legge til, slette eller endre brukere, samt gi brukere admin-tilgang.
      Ta kontakt med styret.'
        redirectUser='/user-admin'
      />
    );
  }

  return (
    <Router>
      <PrivateRoute path='/user-admin/create-user' component={CreateUserPage} />
      <PrivateRoute path='/user-admin/update-user' component={UpdateUserPage} />
      <PrivateRoute path='/user-admin' component={UserAdminPage} />
    </Router>
  );
}

export default UserAdmin;

Hvis brukeren er logget inn, vises komponenten <CreateUserPage> (createUserPage.tsx) og dette skjermbildet dukker opp på skjermen:

Skjermbilde: Opprett ny bruker-dialogboks

Med Chakra UI er det enkelt å lage et skjema som ser fint ut. Reacts useState-hook brukes til å lagre alle dataene som tastes inn i skjemaet i variabelen formData, som et objekt med key/value-par for epost, navn, osv.:

const [formData, setFormData] = useState({
    email: '',
    name: '',
    password: '',
    repeatPassword: '',
    roles: [],
});

Når noen endrer informasjon i ett av feltene, bruker jeg setFormData til å oppdatere tilstand/state for skjemaet. For eksempel slik for Fornavn og etternavn-feltet:

<FormControl id='name' isRequired>
  <FormLabel>Fornavn og etternavn</FormLabel>
  <Input
    value={formData.name}
    placeholder='Fornavn Etternavn'
    onChange={(e) =>
      setFormData((prevState) => {
        return {
          ...prevState,
          name: e.target.value,
        };
      })
    }
  />
</FormControl>

FormControl kommer fra Chakra UI og gir litt ekstra kontroll på feltene i skjemaer, du kan lese mer om det her.

Ved endringer i feltet (onChange) bruker vi spread-operatoren for å fylle inn alle eksisterende data i formData, og så endrer vi formData.name til det som til enhver tid er tastet inn i feltet.

Når brukeren trykker Opprett-knappen, kjøres funksjonen handleSubmit. Vi starter med å validere informasjonen som er tastet inn i feltene. Her sjekker jeg om begge passordfeltene er identiske, samt at passordet som er tastet inn inneholder både tall og store og små bokstaver, og at passordet er minst 8 tegn langt:

const handleSubmit = async (event) => {
    event.preventDefault();

    if (formData.password !== formData.repeatPassword) {
      toast({
        title: 'Passordene er ikke like',
        description:
          'Pass på at du har skrevet passordet helt likt i de to feltene.',
        status: 'error',
        duration: 3000,
        isClosable: true,
      });
      return;
    }

    if (!formData.password.match(/((?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,})/)) {
      toast({
        title: 'Ikke sterkt nok passord',
        description:
          'Passordet må inneholde både tall og store og små bokstaver, og være minst 8 tegn langt.',
        status: 'warning',
        duration: 3000,
        isClosable: true,
      });
      return;
    }

// ...resten av handleSubmit-funksjonen

Hvis passordene ikke er like, eller ikke er sterkt nok, bruker jeg Toast-komponenten til Chakra UI for å vise en liten advarsel som popper opp på skjermen noen sekunder, før den forsvinner igjen.

I skjemaet for nye brukere er det også sjekkbokser for hvilke roller den nye brukeren skal ha. Jeg lagrer hvorvidt sjekkboksene er krysset av eller ikke i variablene isAdminChecked og isEditorChecked. Dermed kan jeg gjøre følgende i handleSubmit-funksjonen for å oppdatere roles-arrayet i formData med alle rollene vi vil brukeren skal få:

formData.roles = ['user'];
if (isAdminChecked) {
  formData.roles.push('admin');
}
if (isEditorChecked) {
  formData.roles.push('editor');
}

Alle brukere skal ha rollen 'user', derfor trenger vi bare å sjekke for admin og editor (og legge til 'user' for alle).

Kontakte serverless-funksjonen for å opprette brukeren

Vi har nå oppdatert formData så det inneholder et JavaScript-objekt med alle nødvendige data om brukeren. Det kan for eksempel se slik ut:

{
    email: 'ola@nordmann.no',
    name: 'Ola Nordmann',
    password: 'InnmariBraPassord123',
    repeatPassword: 'InnmariBraPassord123',
    roles: ['user', 'admin'],
}

Vi kan nå kalle en Gatsby Function (serverless function) vi har kalt create-user for å opprette brukeren. Den ligger i likhet med alle Gatsby Functions under /src/api/. Her er kodesnutten som gjør dette (vi er fortsatt i handleSubmit-funksjonen i <CreateUserPage>-komponenten på klienten:

try {
      const accessToken = await getAccessTokenSilently(opts);
      const api = await fetch(`/api/admin-users/create-user`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          Authorization: `Bearer ${accessToken}`,
        },

        body: JSON.stringify(formData),
      });

      if (api?.status !== 200) {
        throw new Error(`${api.statusText} (${api.status})`);
      }

      const isJson = api.headers
        .get('content-type')
        ?.includes('application/json');

      const data = isJson && (await api.json());

      if (!data) {
        throw new Error('no_data');
      }

      if (data.error) {
        const { error_description } = JSON.parse(data?.error_description);
        throw new Error(`${data.error} : ${JSON.stringify(error_description)}`);
      }

      // Store the API response (e.g. the user data for the newly created user)
      setResponse(data?.body?.user);

      setShowLoadingButton(false);
    } catch (error) {
      if (
        error.message.includes(
          'Consent required' || 'Forbidden (403)' || 'access_denied'
        )
      ) {
        getToken();
      }

      if (error.message === 'Conflict (409)') {
        toast({
          title: 'Brukeren eksistererer allerede',
          description:
            'Hver bruker må ha en unik epost-adresse og et unikt navn.',
          status: 'error',
          duration: 3000,
          isClosable: true,
        });
      } else {
        toast({
          title: 'Noe gikk galt',
          description: `${error.message}`,
          status: 'error',
          duration: 3000,
          isClosable: true,
        });
      }
      setResponse(null);
      setShowLoadingButton(false);
    }

Hvis vi starter på toppen: Først henter vi brukerens access token fra Auth0 med getAccessTokenSilently(opts). opts har vi satt lenger opp i koden:

const opts = {
    audience: 'https://useradmin.gartnerihagen-askim.no',
    scope: 'create:users read:roles create:role_members',
  };

Scope er hvilke tillatelser brukeren må ha, og her trenger vi altså tillatelser til å opprette en bruker og oppdatere rollene til brukeren. Se også Auth0s dokumentasjon på hvordan du kaller et beskyttet API med et access token her.

Vi har nå mottatt et access token som vi kan sende med i autorisasjons-headeren når vi kaller create-user-API-et vårt. I tillegg sender vi med formData — altså infoen om brukeren vi vil opprette — i body:

const api = await fetch(`/api/admin-users/create-user`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${accessToken}`,
    },

    body: JSON.stringify(formData),
});

Serverless-funksjonen for å opprette brukere

Vår serverless-funksjon create-user vil nå motta en POST-request der access-tokenet ligger i autorisasjons-headeren og info om brukeren som skal opprettes ("payload") ligger i body.

Før vi kaller Auth0 sitt Management API for å opprette brukeren, er det lurt å sjekke litt først. Jeg bruker biblioteket @serverless-jwt/jwt-verifier for å lese access-tokenet som klienten nettopp sendte, og så bruker jeg jwt.verifyAccessToken for å sjekke at det er et gyldig token. Jeg henter også ut alle tillatelsene (scopes) fra access-tokenet, og sjekker at brukeren faktisk har de tillatelsene vedkommende trenger for å opprette en bruker. Her sjekker jeg kun for scopet create:users, siden jeg tenker at hvis brukeren har denne tillatelsen så er det ikke nødvendig å sjekke om vedkommende har tillatelse til også å lese roller eller tilegne brukeren roller. Det ligger i kortene.

Her er første del av serverless-funksjonen vår:

// src/api/admin-users/create-user.ts

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

const ALLOWED_ROLES = ['user', 'admin', 'editor'];

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);
  const userRoles = req.body.roles;

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

  userRoles.forEach((role) => {
    if (!ALLOWED_ROLES.includes(role)) {
      return res.status(403).json({
        error: 'invalid user role',
        error_description: 'Serveren mottok en ugyldig brukerrolle',
      });
    }
  });

  // 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('create:users')) {
    return res.status(403).json({
      error: 'no create access',
      status_code: res.statusCode,
      error_description:
        'Du må ha admin-tilgang for å opprette brukere. Ta kontakt med styret.',
      body: {
        data: [],
      },
    });
  }

// ...create-user.ts fortsetter

Hvis vi har kommet så langt, er det ikke noe i veien for at vi ikke skal få lov til å opprette den nye brukeren. Vi oppretter en ny Auth0 ManagementClient:

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: 'create:users read:roles create:role_members',
});

Så lager vi en konstant userData som inneholder et objekt med data om brukeren som vi henter fra req.body. Det som ligger under connection nedenfor er navnet på databasen hos Auth0 som brukes til å lagre alle brukerne.

const userData = {
  connection: 'Username-Password-Authentication',
  email: req.body.email,
  name: req.body.name,
  password: req.body.password,
  verify_email: false,
  email_verified: false,
};

Vi kan nå opprette brukeren med createUser-metoden fra Auth0 Management API-SDK-et (alt dette putter vi i en try/catch-blokk så vi får feilhåndtering):

const newUser = await auth0.createUser(userData);

Med mindre noe gikk galt, er brukeren nå opprettet hos Auth0 (og ligger i Username-Password-Authentication-databasen på Auth0s servere). Men vi er ikke helt i mål ennå, vi må gi den nye brukeren de rollene vi huket av i skjemaet på klienten. Da trenger vi ytterligere et par metoder fra Auth0s Management-API: getRoles for å hente alle rollene som er definert hos Auth0, og assignRolesToUser for å tilegne roller:

const allRoles = await auth0.getRoles();
let rolesToAdd = [];
allRoles.forEach((role) => {
  if (userRoles.includes(role.name)) {
    rolesToAdd.push(role.id);
  }
});
await auth0.assignRolestoUser(
  {
    id: newUser.user_id,
  },
  {
    roles: rolesToAdd,
  }
);

Først henter vi alle roller med getRoles og lagrer dette i konstanten allRoles. Deretter lager vi et nytt, tomt array, rolesToAdd, som skal inneholde alle rollene vi til slutt skal legge til for brukeren. Vi bruker så forEach for å gå over alle rollene som finnes hos Auth0, og så sjekke om rollen også finnes i userRoles (som vi i starten av koden hentet fra req.body.roles). Hvis så er tilfelle, legger vi til denne rollen i rolesToAdd-arrayet. Legg merke til at vi må bruke ID-en og ikke navnet til rollen, ettersom metoden assignRolesToUser krever dette.

Når rolesToAdd-arrayet er fylt opp med alle rolle-ID-ene brukeren skal ha, kaller vi assignRolesToUser med ID-en til den nye brukeren (som vi fikk da vi kalte createUser) og arrayet med alle rollene som skal legges til.

Gikk alt som det skulle, returnerer vi den nye brukeren og rollene tilbake til klienten — som en bekreftelse på at brukeren er opprettet:

res.status(200).json({
    body: {
      status_code: 200,
      status_description: 'Ny bruker er opprettet',
      user: { ...newUser, roles: userRoles },
    },
  });

Hele kildekoden til create-user finner du på min Github her.

Bekreftelse på at ny bruker er opprettet

Når klienten (dvs. <CreateUserPage>-komponenten) mottar responsen fra API-et, sjekker jeg først at vi mottok HTTP-statuskode 200, som indikerer at alt er OK. Dette gjør jeg inni en try/catch-blokk, slik at jeg kan bruke throw new Error() og håndtere feilen (jeg bruker Toast-komponenten til Chakra UI for å vise en fornuftig feilmelding).

Hvis alt gikk som det skulle, mottar jeg data om den nye brukeren fra API-et, og jeg bruker useState-hooken i React til å lagre data om brukeren i variabelen response slik: setResponse(data?.body?.user)

Til slutt bruker jeg en modal-komponent i Chakra UI for å vise en bekreftelse på at brukeren er opprettet, med bruker-informasjonen vi nettopp fikk fra API-et:

Skjermbilde: Ny bruker er opprettet.

Oppdatering av brukere

Oppdatering av brukere er ikke så veldig forskjellig. Når vi trykker på knappen "Endre bruker" på en av brukerne i brukeradmin-dashbordet navigerer vi til ruten /user-admin/update-user med Gatsbys navigate-funksjon og sender med data om den aktuelle brukeren som propertyen state. Fra komponenten userAdminPage.tsx:

onClick={() =>
    navigate('/user-admin/update-user', {
      state: userToShow,
    })
}

Hvis brukeren er autentisert, lastes komponenten UpdateUserPage via Reach Router som er innebygget i Gatsby. Vi får tilgang til brukerdataene via props.location.state slik: const userToModify = props?.location?.state.

Deretter bruker jeg useState-hooken i React til å sette opp en variabel med et objekt som skal inneholde nåværende state for brukeren jeg skal oppdatere:

const [userDataForm, setUserDataForm] = useState({
    created_at: '',
    last_login: '',
    email: '',
    name: '',
    picture: '',
    roles: [],
    user_id: '',
  });

Første gang komponenten rendres, setter jeg userDataForm til å være lik brukerdataene vi nettopp fikk via props.location.state, slik:

useEffect(() => {
  setUserDataForm({
    ...userToModify,
    roles: [...userToModify.roles],
  });
}, []);

Jeg skal ikke gå i detalj på alt jeg gjør på klienten for å oppdatere brukeren, det handler stort sett bare om å forhåndsutfylle et skjema med info om brukeren vi skal redigere, og så ved endringer på noen av feltene i skjemaet bruke setUserDataForm til å oppdatere state (omtrent som vi gjorde i skjemaet for oppretting av ny bruker). Dette er skjermbildet man får opp når man trykker Endre bruker:

Skjermbilde: oppdater bruker.

Hele kildekoden til komponenten UpdateUserPage finner du på min Github.

Kalle serverless-funksjonen for å oppdatere brukeren

Jeg lagde en handleSubmit-funksjon som kalles når vi trykker "Oppdater"-knappen i skjemaet. handleSubmit henter først access-tokenet til den innloggede brukeren, og jeg spesifiserer at brukeren trenger tillatelsene update:users, read:roles og create:role_members. Så gjør vi en PATCH-request til vår serverless Gatsby Function update-user, og sender access-tokenet i autentiserings-headeren og de oppdaterte dataene om brukeren (userDataForm) som body:

const opts = {
  audience: 'https://useradmin.gartnerihagen-askim.no',
  scope: 'update:users read:roles create:role_members',
};

try {
      const accessToken = await getAccessTokenSilently(opts);
      const api = await fetch(`/api/admin-users/update-user`, {
        method: 'PATCH',
        headers: {
          'Content-Type': 'application/json',
          Authorization: `Bearer ${accessToken}`,
        },

        body: JSON.stringify(userDataForm),
      });

// ...resten av koden

Serverless-funksjonen for å oppdatere brukeren

I Gatsby-funksjonen update-user gjør vi mye av det samme som vi gjorde da vi skulle opprette en bruker. Vi verifiserer access-tokenet og sjekker at klienten som kaller API-et har de nødvendige tillatelsene. Så bruker vi Auth0s Management API-SDK til å opprette en ny ManagementClient som vi kaller auth0, og deretter auth0.updateUser() for å oppdatere brukeren. updateUser() krever at du sender inn ID-en til brukeren du vil oppdatere som parameter, sammen med de oppdaterte brukerdataene:

const updatedUser = await auth0.updateUser(
  { id: req.body.user_id },
  userData
);

I tillegg må vi legge til og/eller fjerne roller fra brukeren. Jeg lager her et tomt array jeg kaller rolesToRemove og et annet jeg kaller rolesToAdd. Så går jeg over alle roller som er definert hos Auth0, og ser om rollene eksisterer eller ikke, og bruker henholdsvis auth0.assignRolesToUser og auth0.removeRolesFromUser for å legge til eller fjerne roller. Til slutt returnerer API-et vårt info om den oppdaterte brukeren og hvilke roller som er fjernet eller lagt til. Hvis noe går galt (for eksempel hvis Auth0s Management API klager på noe), fanges dette opp av catch-blokken — som returnerer feilinformasjon til klienten. Isåfall bruker jeg Toast-komponenten til Chakra UI for å gi en forhåpentligvis meningsfull feilmelding til brukeren.

Her er resten av backend-koden som oppdaterer brukeren og rollene til brukeren:

// src/api/admin-users/update-user.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: 'update:users read:roles create:role_members',
  });

  const userData = {
    connection: 'Username-Password-Authentication',
    email: req.body.email,
    name: req.body.name,
  };

  try {
    const updatedUser = await auth0.updateUser(
      { id: req.body.user_id },
      userData
    );
    const allRoles = await auth0.getRoles();

    let rolesToRemove = [];
    allRoles.forEach((role) => {
      if (!userRoles.includes(role.name)) {
        rolesToRemove.push(role.id);
      }
    });

    let rolesToAdd = [];
    allRoles.forEach((role) => {
      if (userRoles.includes(role.name)) {
        rolesToAdd.push(role.id);
      }
    });

    if (rolesToAdd.length > 0) {
      await auth0.assignRolestoUser(
        {
          id: req.body.user_id,
        },
        {
          roles: rolesToAdd,
        }
      );
    }

    if (rolesToRemove.length > 0) {
      await auth0.removeRolesFromUser(
        {
          id: req.body.user_id,
        },
        {
          roles: rolesToRemove,
        }
      );
    }

    res.status(200).json({
      body: {
        status_code: 200,
        status_description: 'Bruker er oppdatert',
        user: updatedUser,
        roles_removed: rolesToRemove,
        roles_added: rolesToAdd,
      },
    });
  } catch (error) {
    res.status(error.statusCode).json({
      error: error.name,
      status_code: error.statusCode || 500,
      error_description: error.message,
    });
  }

Hele greia finner du på Github her.

Slette brukere

Sletting av brukere er ikke så ulikt. Hvis noen trykker Slett bruker-knappen, lagrer jeg bruker-ID-en og navnet til brukeren som skal slettes i userToDelete og viser en advarsel (her bruker jeg AlertDialog-komponenten til Chakra UI).

Skjermbilde: Dialogbokser for å slette bruker

Slette brukere

Bekrefter du at du er sikker på at brukeren skal slettes, kaller jeg funksjonen handleDeleteUser som igjen henter den innloggede brukerens access-token og ber om tillatelsen delete:users. Så gjøres en DELETE-request til vår serverless-funksjon delete-user, med access-tokenet i autorisasjons-headeren og userToDelete i body:

const handleDeleteUser = async () => {
    const opts = {
      audience: 'https://useradmin.gartnerihagen-askim.no',
      scope: 'delete:users',
    };

    try {
      if (!userToDelete.id.includes('auth0')) {
        throw new Error('User ID is not valid');
      }

      const accessToken = await getAccessTokenSilently(opts);
      const api = await fetch(`/api/admin-users/delete-user`, {
        method: 'DELETE',
        headers: {
          'Content-Type': 'application/json',
          Authorization: `Bearer ${accessToken}`,
        },

        body: JSON.stringify({ idToDelete: userToDelete.id }),
      });

// ... resten av koden

Serverless-funksjonen (API-et vårt) for å slette brukere sjekker så at access-tokenet er gyldig, at brukeren har rettigheter til å slette brukere, samt at bruker-ID-en som er sendt med i req.body.idToDelete er gyldig. Er den det, er det å slette en bruker i Auth0 så enkelt som å opprette en ny Auth0 ManagementClient som vi kaller auth0, og så kalle auth0.deleteUser(). Slik:

// src/api/admin-users/delete-user.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: 'delete:users',
  });

  try {
    const idToDelete = req.body.idToDelete;

    if (!idToDelete || !idToDelete.includes('auth0')) {
      const error = {
        name: 'bad user id',
        statusCode: 400,
        message: 'Manglende bruker-id eller feil format',
      };
      throw error;
    }

    await auth0.deleteUser({ id: idToDelete });

    res.status(200).json({
      body: {
        status_code: 200,
        status_description: 'Bruker er slettet',
      },
    });
  } catch (error) {
    res.status(error.statusCode || 500).json({
      error: error.name,
      status_code: error.statusCode || 500,
      error_description: error.message,
    });
  }

Hvis alt går som det skal, returneres statuskode 200. Vi sjekker dette på klienten (i userAdminPage.tsx) og bruker Chakra UIs Toast-funksjon for å varsle om at brukeren er slettet.

Hva nå?

Puh! Jeg er i mål og har nå en nettside med brukeradministrasjon!

Jeg har ikke gått i detalj på alle kriker og kroker av hvordan denne løsningen er bygget opp, men oppfordrer i stedet til å ta en kikk på kildekoden som ligger på min Github.

Da jeg startet jobben med å lage nye nettsider til sameiet, tenkte jeg at dette skulle være ganske fort gjort — men er det én ting jeg har lært av prosjektet, så er det at en slik nettside aldri blir ferdig. Det er alltid ett eller annet som kan forbedres.

Jeg kommer nok til å bruke litt tid innimellom til å refaktorere og forbedre koden for å gjøre ting litt ryddigere, og så er planen også å lage en serverless-funksjon som automatisk varsler registrerte brukere når nytt innhold publiseres. Her kommer jeg til sette opp en webhook hos Contentful som kaller en Gatsby Function som bruker Sendgrids node-løsning til å sende en epost med lenke til det nye innholdet.

Har du tilbakemeldinger på noe av det jeg har gjort, eller forslag til ting som kan forbedres, bruk gjerne kommentarfeltet under artiklene mine på lekanger.no — eller send meg en epost på kurt@lekanger.no.

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