Skip to content

React Library Reference

Installation

$ npm install --save @propelauth/react 
$ yarn add @propelauth/react

Set up AuthProvider

AuthProvider is the provider of a React context that manages the current user's access token and metadata. You cannot use the other hooks without it. AuthProvider is the component that manages authentication information and all other components fetches from it.

It is recommended to put the AuthProvider component at the top level of your application, so it never unmounts.

import {AuthProvider} from "@propelauth/react";

const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(
    <AuthProvider authUrl={process.env.REACT_APP_AUTH_URL}> // (1)
        <YourApp/>
    </AuthProvider>,
    document.getElementById("root")
);
  1. The authUrl is the base URL where your authentication pages are hosted. You can find this under the Frontend Integration section for your project.

RequiredAuthProvider

If your entire application requires a user to be logged in, you can instead use RequiredAuthProvider.

import {RequiredAuthProvider, RedirectToLogin} from "@propelauth/react";

const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(
    <RequiredAuthProvider authUrl={process.env.REACT_APP_AUTH_URL} 
                          displayWhileLoading={<Loading/>} 
                          displayIfLoggedOut={<RedirectToLogin/>}>
        <YourApp/>
    </RequiredAuthProvider>,
    document.getElementById("root")
);

RequiredAuthProvider has two additional props:

  1. displayWhileLoading: A React element to display while the AuthProvider is fetching auth information. Defaults to an empty element
  2. displayIfLoggedOut: A React element to display if the current user is logged out. Defaults to <RedirectToLogin />

Get current user information

There are three options for getting the current user's information:

import {withAuthInfo} from '@propelauth/react';

function MinimalExample(props) {
    // isLoggedIn and user are injected automatically from withAuthInfo below
    if (props.isLoggedIn) {
        return <div>You are logged in as {props.user.email}</div>
    } else {
        return <div>You are not logged in</div>
    }
}

export default withAuthInfo(MinimalExample); // (1)
  1. A React Higher-Order Component that provides common values like isLoggedIn and accessToken. These values are injected into the props of your component.
import {withRequiredAuthInfo} from '@propelauth/react';

function MinimalExample(props) {
    // user is injected automatically from withRequiredAuthInfo below
    return <div>You are logged in as {props.user.email}</div>
}

export default withRequiredAuthInfo(MinimalExample); // (1)
  1. Similar to withAuthInfo, except if the user isn't logged in, they are redirected to the login page (that behavior is configurable).
import {useAuthInfo} from '@propelauth/react';

function MinimalExample() {
    const authInfo = useAuthInfo()

    // Unlike the higher order functions, we need to check the loading case now
    if (authInfo.loading) {
        return <div>Loading...</div>
    } else if (authInfo.isLoggedIn) {
        return <div>You are logged in as {props.user.email}</div>
    } else {
        return <div>You are not logged in</div>
    }
}

export default MinimalExample; 

When is an external API call made?

The AuthProvider component manages all external API requests. The functions withAuthInfo, withRequiredAuthInfo, and useAuthInfo only extract information from requests without making their own requests. For this reason, you can (and should) add as many of these functions as you need.

withAuthInfo

withAuthInfo(Component, {
    displayWhileLoading: <div>Loading...</div>, // (1)
})
  1. A React element to display while the AuthProvider is fetching auth information. Defaults to an empty element

which will inject the following props into Component:

Prop Description
accessToken If the user is logged in, this string can access your APIs on behalf of the user. Otherwise, null
isLoggedIn Returns user logged in status
orgHelper An object with useful functions for managing organizations
accessHelper An object with useful functions for accessing role and permissions (RBAC)
user If the user is logged in, this contains metadata about them. Otherwise, null

withRequiredAuthInfo

withRequiredAuthInfo(Component, {
    displayWhileLoading: <div>Loading...</div>, // (1)
    displayIfLoggedOut: <div>You are logged out</div> // (2)
})
  1. A React element to display while the AuthProvider is fetching auth information. Defaults to an empty element
  2. A React element to display if the current user is logged out. Defaults to <RedirectToLogin />

This is identical to withAuthInfo, except Component is only rendered if the user is logged in. You are guaranteed that isLoggedIn is true and the accessToken is not null.

useAuthInfo

function Component() {
    const authInfo = useAuthInfo()
    // ...rest of the component
}

A React hook which gets auth information. authInfo contains:

Key Description
loading True if the AuthProvider is still fetching auth information. This will only happen once when the application is first loaded.
accessToken If user is logged in, this string can access your APIs on behalf of the user. Otherwise, null
isLoggedIn Returns user logged in status
orgHelper An object with useful functions for managing organizations
accessHelper An object with useful functions for accessing role and permissions (RBAC)
user If user is logged in, this contains metadata about them. Otherwise, null

Logout

function LogoutButton() {
    const logoutFn = useLogoutFunction(); // (1)
    return <button onClick={() => logoutFn(true) /*(2)*/}>Logout</button>
}
  1. A React hook that returns a function which logs the current user out.
  2. The function takes a single parameter redirectOnLogout. If true, the function will redirect the user to the logout URL configured in the Frontend Integration section of your project.

useRedirectFunctions

function SignupAndLoginButtons() {
    const {redirectToSignupPage, redirectToLoginPage} = useRedirectFunctions();
    return <div>
        <button onClick={redirectToSignupPage}>Signup</button>
        <button onClick={redirectToLoginPage}>Login</button>
    </div>
}

A React hook that returns a collection of functions which redirect the user to useful locations.

Function Description
redirectToAccountPage() Redirects the user to the account hosted authentication page, where they can view/modify their user information.
redirectToSignupPage() Redirects the user to the signup hosted authentication page.
redirectToLoginPage() Redirects the user to the login hosted authentication page.
redirectToOrgPage(orgId?) Redirects the user to an organization management hosted authentication page. If orgId is specified, redirect to that organization's page. If none is specified, a default is chosen deterministically.
redirectToCreateOrgPage() Redirects the user to the hosted authentication page where they can create organizations.

RedirectToLogin

function Private(props) {
    return <div>You are logged in as {props.user.email}</div>
}

export default withRequiredAuthInfo(Private, {
    displayIfLoggedOut: <RedirectToLogin />, //(1)
});
  1. When this component is rendered, if the user isn't logged in, it will redirect to the login page

A React component that redirects the user to the login hosted authentication page when rendered. This is identical to calling redirectToLoginPage from useRedirectFunctions.

RedirectToSignup

function Private(props) {
    return <div>You are logged in as {props.user.email}</div>
}

export default withRequiredAuthInfo(Private, {
    displayIfLoggedOut: <RedirectToSignup />, //(1)
});
  1. When this component is rendered, if the user isn't logged in, it will redirect to the signup page

A React component that redirects the user to the signup hosted authentication page when rendered. This is identical to calling redirectToSignupPage from useRedirectFunctions.

Schemas

The User object

type User = {
    userId: string

    email: string
    emailConfirmed: boolean,

    hasPassword: boolean,

    username?: string
    firstName?: string,
    lastName?: string,
    pictureUrl?: string,

    locked: boolean,
    enabled: boolean,
    mfaEnabled: boolean,

    createdAt: number,
    lastActiveAt: number,

    legacyUserId?: string
}

The orgHelper

The orgHelper helps manage the current user's organization information with ease. It's an object which has the following functions (types included):

type OrgHelper = {
    // returns all orgs that the user is a member of
    getOrgs: () => OrgMemberInfo[],
    // returns all org ids that the user is a member of
    getOrgIds: () => string[],
    // returns org information for a given orgId
    getOrg: (orgId: string) => OrgMemberInfo | undefined,
    // returns org information for a given org by name
    getOrgByName: (orgName: string) => OrgMemberInfo | undefined,
}
type OrgMemberInfo = {
    orgId: string,
    orgName: string,
    urlSafeOrgName: string
    // The role of the user within this organization
    userAssignedRole: string
    userPermissions: string[]
}

You can either get the orgHelper from useAuthInfo, withAuthInfo, or withRequiredAuthInfo - or you can access it directly from the hook useOrgHelper.

The accessHelper

Your users will have a role in an organization. By default, these roles are Owner, Admin, and Member - but you can configure them. Each role can have permissions associated with them. See roles and permissions for more details.

The accessHelper, provided by withAuthInfo, withRequiredAuthInfo, or useAuthInfo, helps check the current user's role and permission(s) within a specific organization.

type AccessHelper = {
    isRole: (orgId: string, role: string) => boolean
    isAtLeastRole: (orgId: string, role: string) => boolean
    hasPermission: (orgId: string, permission: string) => boolean
    hasAllPermissions: (orgId: string, permissions: string[]) => boolean
}

Active Organization

Since users can be in more than one organization, one common use case is to pick a single organization that your user is currently operating within.

Commonly, developers use localStorage, a path parameter, or subdomain (e.g. https://CUSTOMER.yourproduct.com or https://app.yourproduct.com/CUSTOMER) to indicate which organization the user is currently operating within.

The AuthProvider and RequiredAuthProvider optionally take in a getActiveOrgFn which enables you to select the currently active organization, like so:

// Get the active org from a path parameter grabbed from our router
<AuthProvider authUrl={AUTH_URL} getActiveOrgFn={() => router.query.orgName}>
  • useActiveOrg allows you to fetch the active organization later on. It will also verify that the current user is actually in that organization.
function OrgName() {
    const org = useActiveOrg()
    return <div>{org.orgName}</div>
}

Examples

Display the users email for logged in users

function Example(props) {
    // isLoggedIn and user are injected automatically from withAuthInfo below
    if (props.isLoggedIn) {
        return <div>Email: {props.user.email}</div>
    } else {
        return <div>Email: None</div>
    }
}

export default withAuthInfo(Example);

Display buttons for signup and login

function SignupAndLoginButtons() {
    const {redirectToSignupPage, redirectToLoginPage} = useRedirectFunctions();
    return <div>
        <button onClick={redirectToSignupPage}>Signup</button>
        <button onClick={redirectToLoginPage}>Login</button>
    </div>
}

Display Signup and Login buttons (for logged out users) or a Logout button (for logged in users)

import {withAuthInfo, useLogoutFunction, useRedirectFunctions} from '@propelauth/react';

function AuthenticationButtons({isLoggedIn}) {
    const logoutFn = useLogoutFunction()
    const {redirectToSignupPage, redirectToLoginPage} = useRedirectFunctions()

    if (isLoggedIn) {
        return <button onClick={() => logoutFn(true)}>Logout</button>
    } else {
        return <div>
            <button onClick={redirectToSignupPage}>Signup</button>
            <button onClick={redirectToLoginPage}>Login</button>
        </div>
    }
}

export default withAuthInfo(AuthenticationButtons);

Display the user's profile picture

You must enable Profile Picture support first.

import {withAuthInfo} from '@propelauth/react';

function ProfilePicture({isLoggedIn, user}) {
    if (isLoggedIn) {
        return <img src={user.pictureUrl} />
    } else {
        return null;
    }
}

export default withAuthInfo(ProfilePicture)