feat: merging master changes with stabilizaing auth0

.eslintrc.json

@@ -16,6 +16,7 @@
   },
   "rules": {
     /* React rules */
+    "react/react-in-jsx-scope": "off",
     "react/no-direct-mutation-state": "error",
     "react/no-unused-prop-types": "warn",
     "react/self-closing-comp": [

.github/workflows/ci.yml

@@ -6,6 +6,11 @@ on:
       - 'next'
       - 'v3.x'
 
+permissions:
+  packages: write
+  contents: write
+  id-token: write
+
 jobs:
   deploy:
     name: Deploy

__mocks__/@auth0/auth0-spa-js.ts

@@ -38,57 +38,55 @@ export const handleRedirectCallback = jest.fn(() => {
 export const isAuthenticated = jest.fn();
 export const logout = jest.fn();
 export const loginWithPopup = jest.fn();
-export const createAuth0Client = jest.fn().mockImplementation((options: any) =>
-  Promise.resolve({
-    getTokenSilently,
-    loginWithRedirect,
-    loginWithPopup,
-    getUser,
-    logout,
-    handleRedirectCallback,
-    isAuthenticated,
-    options: {
-      ...options,
-      onRedirectCallback,
-    },
-    cacheLocation: 'localstorage',
-    httpTimeoutMs: 10000,
-    cookieStorage: {
+export const Auth0Client = jest.fn().mockImplementation((options: any) => ({
+  getTokenSilently,
+  loginWithRedirect,
+  loginWithPopup,
+  getUser,
+  logout,
+  handleRedirectCallback,
+  isAuthenticated,
+  options: {
+    ...options,
+    onRedirectCallback,
+  },
+  cacheLocation: 'localstorage',
+  httpTimeoutMs: 10000,
+  cookieStorage: {
+    get: jest.fn(),
+    save: jest.fn(),
+    remove: jest.fn(),
+  },
+  orgHintCookieName: 'auth0..organization_hint',
+  isAuthenticatedCookieName: 'auth0..is.authenticated',
+  sessionCheckExpiryDays: 1,
+  scope: 'offline_access',
+  transactionManager: {
+    storage: {
       get: jest.fn(),
       save: jest.fn(),
       remove: jest.fn(),
     },
-    orgHintCookieName: 'auth0..organization_hint',
-    isAuthenticatedCookieName: 'auth0..is.authenticated',
-    sessionCheckExpiryDays: 1,
-    scope: 'offline_access',
-    transactionManager: {
-      storage: {
-        get: jest.fn(),
-        save: jest.fn(),
-        remove: jest.fn(),
-      },
-      clientId: '',
-      storageKey: 'a0.spajs.txs.',
-      transaction: null,
-    },
+    clientId: '',
+    storageKey: 'a0.spajs.txs.',
+    transaction: null,
+  },
+  nowProvider: jest.fn(),
+  cacheManager: {
+    cache: {},
+    keyManifest: null,
     nowProvider: jest.fn(),
-    cacheManager: {
-      cache: {},
-      keyManifest: null,
-      nowProvider: jest.fn(),
-    },
-    domainUrl: 'https://',
-    tokenIssuer: 'https:///',
-    defaultScope: 'openid profile email',
-    customOptions: {
-      onRedirectCallback,
-      organization: undefined,
-    },
-    useRefreshTokensFallback: true,
-    useRefreshTokens: true,
-  })
-);
+  },
+  domainUrl: 'https://',
+  tokenIssuer: 'https:///',
+  defaultScope: 'openid profile email',
+  customOptions: {
+    onRedirectCallback,
+    organization: undefined,
+  },
+  useRefreshTokensFallback: true,
+  useRefreshTokens: true,
+}));
 
 /*
  * Mock auth0 client with predefined values

package.json

@@ -75,6 +75,7 @@
     "react-dom": "^18.1.0",
     "react-router-dom": "^5.3.1",
     "rimraf": "^3.0.2",
+    "semantic-release": "^22.0.12",
     "ts-jest": "^27.1.4",
     "ts-lib": "^0.0.5",
     "tsc-watch": "^5.0.3",

src/__tests__/Authentication.test.tsx

@@ -14,14 +14,16 @@ class CustomError extends Error {
 import { ErrorBoundary, useErrorHandler } from 'react-error-boundary';
 
 import {
-  fakeTokenData,
   FAKE_TOKEN,
+  fakeTokenData,
   getNewFakeToken,
-  getTokenSilently as mockedGetTokenSilently,
   getUser,
-  handleRedirectCallback as mockedHandleRedirectCallback,
   isAuthenticated,
   loginWithRedirect,
+  logout,
+  Auth0Client as mockedCreateAuth0,
+  getTokenSilently as mockedGetTokenSilently,
+  handleRedirectCallback as mockedHandleRedirectCallback,
 } from '../../__mocks__/@auth0/auth0-spa-js';
 import { defaultAuthenticationContextValues } from '../contexts/authentication';
 import { useAuthentication } from '../hooks/useAuthentication';
@@ -31,7 +33,7 @@ import MockRequest from '../request/mock';
 import { orfiumIdBaseInstance } from '../request/orfium-id-base-instance';
 import useOrganization from '../store/organizations';
 import useRequestToken from '../store/requestToken';
-import { getTokenSilently, logoutAuth, onRedirectCallback } from '../utils/auth';
+import { getAuth0Client, getTokenSilently, logoutAuth, onRedirectCallback } from '../utils/auth';
 
 const TestingComponentSimple = () => {
   const { user, isAuthenticated, isLoading } = useAuthentication();
@@ -284,6 +286,7 @@ describe('Context', () => {
     isAuthenticated.mockResolvedValue(true);
     getUser.mockResolvedValue({
       name: 'John Doe',
+      updated_at: new Date().toDateString(),
     });
 
     const { findByText, getByTestId } = render(
@@ -313,7 +316,7 @@ describe('Context', () => {
         </ErrorBoundary>
       );
 
-      await waitFor(() => expect(loginWithRedirect).toBeCalledTimes(1));
+      await waitFor(() => expect(logout).toBeCalledTimes(1));
     });
 
     test('loginWithRedirect when access token fails and handle an error', async () => {
@@ -422,14 +425,8 @@ describe('Context', () => {
       </Organizations>
     );
 
-    await waitFor(() => expect(screen.getByTestId('isLoading').innerHTML).toBe('false'));
-    await waitFor(() => expect(loginWithRedirect).toBeCalledTimes(1));
-    expect(loginWithRedirect).toBeCalledWith({
-      authorizationParams: {
-        organization: organizationList[0].org_id,
-        invitation: undefined,
-      },
-    });
+    await waitFor(() => expect(screen.getByTestId('isLoading').innerHTML).toBe('true'));
+    await waitFor(() => expect(logout).toBeCalledTimes(1));
   }, 10000);
 
   test('Context default functions', async () => {
@@ -440,4 +437,35 @@ describe('Context', () => {
     expect(await defaultAuthenticationContextValues.logout()).toBe('logged out');
     expect(await defaultAuthenticationContextValues.loginWithRedirect()).toBe(undefined);
   });
+
+  test('getAuth0Client failed process', async () => {
+    expect.assertions(1);
+    mockedCreateAuth0.mockImplementation(() => {
+      throw new Error();
+    });
+    // @ts-ignore
+    client = undefined;
+    try {
+      getAuth0Client();
+    } catch (e) {
+      expect(e).toEqual(new Error(`getAuth0Client Error: Error`));
+    }
+  });
+
+  test('logoutAuth failed process', async () => {
+    expect.assertions(1);
+
+    // @ts-ignore
+    client = undefined;
+    // @ts-ignore make logout fail with no .logout property on client
+    mockedCreateAuth0.mockImplementation(() => {
+      return {};
+    });
+
+    try {
+      await logoutAuth();
+    } catch (e) {
+      expect(e).toEqual(new Error(`logoutAuth Error: client is not defined`));
+    }
+  });
 });

src/__tests__/Toolbox.test.tsx

@@ -3,6 +3,7 @@ import { cleanup, render, waitFor } from '@testing-library/react';
 import {
   getNewFakeToken,
   getTokenSilently,
+  getUser,
   isAuthenticated,
   loginWithRedirect,
 } from '../../__mocks__/@auth0/auth0-spa-js';
@@ -38,7 +39,17 @@ describe('Authentication: ', () => {
 
   xit('renders the test component', async () => {
     getTokenSilently.mockResolvedValue(getNewFakeToken());
+    jest.mock('../store/useUser', () => ({
+      __esModule: true,
+      default: {
+        user: {},
+      },
+    }));
     isAuthenticated.mockResolvedValue(true);
+    getUser.mockResolvedValue({
+      name: 'John Doe',
+      updated_at: new Date().toDateString(),
+    });
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
     mock.onGet('/memberships/').reply(200, [{ org_id: 'a' }]);
@@ -51,7 +62,11 @@ describe('Authentication: ', () => {
 
     expect(await findByTestId('orfium-auth-loading')).toBeTruthy();
 
-    expect(await findByTestId('test')).toBeTruthy();
+    expect(
+      await findByTestId('test', undefined, {
+        timeout: 3000,
+      })
+    ).toBeTruthy();
   });
 
   xit('redirects to login if not authenticated', async () => {
@@ -73,6 +88,10 @@ describe('Authentication: ', () => {
   xit('renders the loading while its authenticating', async () => {
     getTokenSilently.mockResolvedValue(getNewFakeToken());
     isAuthenticated.mockResolvedValue(true);
+    getUser.mockResolvedValue({
+      name: 'John Doe',
+      updated_at: new Date().toDateString(),
+    });
     const { findByTestId } = render(
       <Authentication>
         <TestComp />
@@ -84,6 +103,10 @@ describe('Authentication: ', () => {
   xit('renders the no organization message when it should', async () => {
     getTokenSilently.mockResolvedValue(getNewFakeToken());
     isAuthenticated.mockResolvedValue(true);
+    getUser.mockResolvedValue({
+      name: 'John Doe',
+      updated_at: new Date().toDateString(),
+    });
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
     mock.onGet('/memberships/').replyOnce(200, []);
@@ -95,6 +118,10 @@ describe('Authentication: ', () => {
     );
 
     expect(await findByTestId('orfium-auth-loading')).toBeTruthy();
-    expect(await findByTestId('orfium-no-organizations')).toBeTruthy();
+    expect(
+      await findByTestId('orfium-no-organizations', undefined, {
+        timeout: 13000,
+      })
+    ).toBeTruthy();
   });
 });

src/__tests__/request.test.ts

@@ -1,11 +1,9 @@
 import { cleanup } from '@testing-library/react';
 import { AxiosInstance, type AxiosRequestConfig } from 'axios';
 
-// @ts-ignore
 import { FAKE_TOKEN, getTokenSilently } from '../../__mocks__/@auth0/auth0-spa-js';
-import { createAPIInstance, CreateAPIInstanceType } from '../request/createAPIInstance';
+import { CreateAPIInstanceType, METHODS, createAPIInstance } from '../request';
 import MockRequest from '../request/mock';
-import { METHODS } from '../request/request';
 
 describe('Request: ', () => {
   let factory: CreateAPIInstanceType;

src/contexts/authentication.ts

@@ -50,7 +50,7 @@ export type AuthenticationContextValue = {
   isAuthenticated: boolean;
   isLoading: boolean;
   loginWithRedirect(o?: RedirectLoginOptions): Promise<void>;
-  logout: () => void;
+  logout: (props?: { force?: boolean }) => Promise<void | string>;
   getAccessTokenSilently: GetAccessTokenSilently;
   user: User | undefined;
   permissions: Permissions;