@databiosphere/findable-ui 19.0.0 → 21.0.0

package/src/providers/authentication/credentials/constants.ts

@@ -0,0 +1,5 @@
+import { CredentialsState } from "./types";
+
+export const DEFAULT_CREDENTIALS_STATE: CredentialsState = {
+  credentials: undefined,
+};

package/src/providers/authentication/credentials/context.ts

@@ -0,0 +1,8 @@
+import { createContext } from "react";
+import { DEFAULT_CREDENTIALS_STATE } from "./constants";
+import { CredentialsContextProps } from "./types";
+
+export const CredentialsContext = createContext<CredentialsContextProps>({
+  credentialsDispatch: null,
+  credentialsState: DEFAULT_CREDENTIALS_STATE,
+});

package/src/providers/authentication/credentials/dispatch.ts

@@ -0,0 +1,31 @@
+import {
+  CredentialsActionKind,
+  ResetStateAction,
+  UpdateCredentialsAction,
+  UpdateCredentialsPayload,
+} from "./types";
+
+/**
+ * Update credentials action.
+ * @returns Action.
+ */
+export function resetState(): ResetStateAction {
+  return {
+    payload: undefined,
+    type: CredentialsActionKind.ResetState,
+  };
+}
+
+/**
+ * Update credentials action.
+ * @param payload - Payload.
+ * @returns Action.
+ */
+export function updateCredentials(
+  payload: UpdateCredentialsPayload
+): UpdateCredentialsAction {
+  return {
+    payload,
+    type: CredentialsActionKind.UpdateCredentials,
+  };
+}

package/src/providers/authentication/credentials/hook.ts

@@ -0,0 +1,11 @@
+import { useContext } from "react";
+import { CredentialsContext } from "./context";
+import { CredentialsContextProps } from "./types";
+
+/**
+ * Credentials hook.
+ * @returns credentials context.
+ */
+export const useCredentials = (): CredentialsContextProps => {
+  return useContext<CredentialsContextProps>(CredentialsContext);
+};

package/src/providers/authentication/credentials/reducer.ts

@@ -0,0 +1,30 @@
+import { updateCredentialsAction } from "./actions";
+import { DEFAULT_CREDENTIALS_STATE } from "./constants";
+import {
+  CredentialsAction,
+  CredentialsActionKind,
+  CredentialsState,
+} from "./types";
+
+/**
+ * Credentials reducer.
+ * @param state - State.
+ * @param action - Action.
+ * @returns state.
+ */
+export function credentialsReducer(
+  state: CredentialsState,
+  action: CredentialsAction
+): CredentialsState {
+  const { payload, type } = action;
+  switch (type) {
+    case CredentialsActionKind.ResetState: {
+      return DEFAULT_CREDENTIALS_STATE;
+    }
+    case CredentialsActionKind.UpdateCredentials: {
+      return updateCredentialsAction(state, payload);
+    }
+    default:
+      return state;
+  }
+}

package/src/providers/authentication/credentials/types.ts

@@ -0,0 +1,33 @@
+import { Dispatch } from "react";
+
+export type Credentials<C = string | undefined> = C;
+
+export type CredentialsAction = ResetStateAction | UpdateCredentialsAction;
+
+export enum CredentialsActionKind {
+  ResetState = "RESET_STATE",
+  UpdateCredentials = "STORE_CREDENTIALS",
+}
+
+export interface CredentialsContextProps {
+  credentialsDispatch: Dispatch<CredentialsAction> | null;
+  credentialsState: CredentialsState;
+}
+
+export interface CredentialsState {
+  credentials: Credentials;
+}
+
+export type ResetStateAction = {
+  payload: ResetStatePayload;
+  type: CredentialsActionKind.ResetState;
+};
+
+export type ResetStatePayload = undefined;
+
+export type UpdateCredentialsAction = {
+  payload: UpdateCredentialsPayload;
+  type: CredentialsActionKind.UpdateCredentials;
+};
+
+export type UpdateCredentialsPayload = Credentials;

package/src/providers/authentication/terra/context.ts

@@ -0,0 +1,16 @@
+import { createContext } from "react";
+import { LOGIN_STATUS_NOT_STARTED } from "./hooks/common/constants";
+import { LoginStatus } from "./hooks/common/entities";
+import { TerraNIHResponse } from "./hooks/useFetchTerraNIHProfile";
+import { TerraResponse } from "./hooks/useFetchTerraProfile";
+import { TerraTermsOfServiceResponse } from "./hooks/useFetchTerraTermsOfService";
+import { TerraProfileContextProps } from "./types";
+
+export const TerraProfileContext = createContext<TerraProfileContextProps>({
+  terraNIHProfileLoginStatus:
+    LOGIN_STATUS_NOT_STARTED as LoginStatus<TerraNIHResponse>,
+  terraProfileLoginStatus:
+    LOGIN_STATUS_NOT_STARTED as LoginStatus<TerraResponse>,
+  terraTOSLoginStatus:
+    LOGIN_STATUS_NOT_STARTED as LoginStatus<TerraTermsOfServiceResponse>,
+});

package/src/providers/authentication/terra/hook.ts

@@ -0,0 +1,11 @@
+import { useContext } from "react";
+import { TerraProfileContext } from "./context";
+import { TerraProfileContextProps } from "./types";
+
+/**
+ * Terra profile hook.
+ * @returns terra profile context.
+ */
+export const useTerraProfile = (): TerraProfileContextProps => {
+  return useContext<TerraProfileContextProps>(TerraProfileContext);
+};

package/src/{hooks/useAuthentication → providers/authentication/terra/hooks}/common/constants.ts

@@ -20,3 +20,12 @@ export const LOGIN_STATUS_NOT_SUPPORTED: LoginStatus<LoginResponse> = {
   requestStatus: REQUEST_STATUS.NOT_STARTED,
   response: undefined,
 };
+
+export const LOGIN_STATUS_PENDING: LoginStatus<LoginResponse> = {
+  isSuccess: false,
+  isSupported: true,
+  requestStatus: REQUEST_STATUS.PENDING,
+  response: undefined,
+};
+
+export const TERRA_SERVICE_ID = "terra";

package/src/{hooks/useAuthentication → providers/authentication/terra/hooks}/common/entities.ts

@@ -1,15 +1,8 @@
-import { GoogleResponse } from "../useFetchGoogleProfile";
 import { TerraNIHResponse } from "../useFetchTerraNIHProfile";
 import { TerraResponse } from "../useFetchTerraProfile";
 import { TerraTermsOfServiceResponse } from "../useFetchTerraTermsOfService";
 
-export enum AUTHENTICATION_STATUS {
-  COMPLETED = "COMPLETED",
-  INCOMPLETE = "INCOMPLETE",
-}
-
 export type LoginResponse =
-  | GoogleResponse
   | TerraResponse
   | TerraNIHResponse
   | TerraTermsOfServiceResponse;
@@ -31,4 +24,5 @@ export enum REQUEST_STATUS {
   COMPLETED = "COMPLETED",
   FAILED = "FAILED",
   NOT_STARTED = "NOT_STARTED",
+  PENDING = "PENDING",
 }

package/src/providers/authentication/terra/hooks/useFetchProfiles.ts

@@ -0,0 +1,61 @@
+import { useEffect, useState } from "react";
+import { useAuthentication } from "../../authentication/hook";
+import { TERRA_PROFILE_STATUS } from "../types";
+import { getProfileStatus } from "../utils";
+import { LoginStatus } from "./common/entities";
+import {
+  TerraNIHResponse,
+  useFetchTerraNIHProfile,
+} from "./useFetchTerraNIHProfile";
+import { TerraResponse, useFetchTerraProfile } from "./useFetchTerraProfile";
+import {
+  TerraTermsOfServiceResponse,
+  useFetchTerraTermsOfService,
+} from "./useFetchTerraTermsOfService";
+
+export interface UseFetchProfiles {
+  isAuthenticated: boolean;
+  isComplete: boolean;
+  isProfileActive: boolean;
+  terraNIHProfileLoginStatus: LoginStatus<TerraNIHResponse>;
+  terraProfileLoginStatus: LoginStatus<TerraResponse>;
+  terraTOSLoginStatus: LoginStatus<TerraTermsOfServiceResponse>;
+}
+
+export const useFetchProfiles = (token?: string): UseFetchProfiles => {
+  const [status, setStatus] = useState<TERRA_PROFILE_STATUS>(
+    TERRA_PROFILE_STATUS.PENDING
+  );
+  const {
+    authenticationState: { profile },
+  } = useAuthentication();
+  const isUserAuthenticated = !!profile;
+  const terraNIHProfileLoginStatus = useFetchTerraNIHProfile(token);
+  const terraProfileLoginStatus = useFetchTerraProfile(token);
+  const terraTOSLoginStatus = useFetchTerraTermsOfService(token);
+
+  useEffect(() => {
+    setStatus(
+      getProfileStatus(
+        isUserAuthenticated,
+        terraNIHProfileLoginStatus,
+        terraProfileLoginStatus,
+        terraTOSLoginStatus
+      )
+    );
+  }, [
+    isUserAuthenticated,
+    terraNIHProfileLoginStatus,
+    terraProfileLoginStatus,
+    terraTOSLoginStatus,
+  ]);
+
+  return {
+    isAuthenticated: isUserAuthenticated,
+    isComplete: status !== TERRA_PROFILE_STATUS.PENDING,
+    isProfileActive: status === TERRA_PROFILE_STATUS.AUTHENTICATED,
+    terraNIHProfileLoginStatus,
+    terraProfileLoginStatus,
+    terraTOSLoginStatus,
+  };
+};

package/src/{hooks/useAuthentication → providers/authentication/terra/hooks}/useFetchTerraNIHProfile.ts

@@ -1,6 +1,11 @@
 import { useCallback, useEffect, useState } from "react";
-import { useAuthenticationConfig } from "../useAuthenticationConfig";
-import { LOGIN_STATUS_FAILED } from "./common/constants";
+import { useAuthenticationConfig } from "../../../../hooks/authentication/config/useAuthenticationConfig";
+import {
+  LOGIN_STATUS_FAILED,
+  LOGIN_STATUS_NOT_STARTED,
+  LOGIN_STATUS_PENDING,
+  TERRA_SERVICE_ID,
+} from "./common/constants";
 import {
   LoginResponseError,
   LoginStatus,
@@ -10,6 +15,9 @@ import {
   getAuthenticationRequestOptions,
   initLoginStatus,
 } from "./common/utils";
+import { getServiceEndpoint } from "./utils";
+
+const ENDPOINT_ID = "nihStatus";
 
 interface DatasetPermission {
   authorized: boolean;
@@ -30,16 +38,20 @@ export interface TerraNIHResponse {
  * @returns Terra NIH login status.
  */
 export const useFetchTerraNIHProfile = (token?: string): Status => {
-  const authenticationConfig = useAuthenticationConfig();
-  const { terraAuthConfig: { terraNIHProfileEndpoint: endpoint } = {} } =
-    authenticationConfig;
+  const { services } = useAuthenticationConfig() || {};
+  const endpoint = getServiceEndpoint(services, TERRA_SERVICE_ID, ENDPOINT_ID);
   const [loginStatus, setLoginStatus] = useState<Status>(
     initLoginStatus(endpoint) as Status
   );
 
   // Fetch Terra NIH account profile.
   const fetchEndpointData = useCallback(
-    (endpoint: string, accessToken: string): void => {
+    (endpoint: string, accessToken?: string): void => {
+      if (!accessToken) {
+        setLoginStatus(LOGIN_STATUS_NOT_STARTED as Status);
+        return;
+      }
+      setLoginStatus(LOGIN_STATUS_PENDING as Status);
       fetch(endpoint, getAuthenticationRequestOptions(accessToken))
         .then((response) => response.json())
         .then((response: LoginResponseError | TerraNIHResponse) => {
@@ -64,7 +76,6 @@ export const useFetchTerraNIHProfile = (token?: string): Status => {
 
   // Fetches Terra NIH account profile.
   useEffect(() => {
-    if (!token) return;
     if (!endpoint) return;
     fetchEndpointData(endpoint, token);
   }, [endpoint, fetchEndpointData, token]);

package/src/{hooks/useAuthentication → providers/authentication/terra/hooks}/useFetchTerraProfile.ts

@@ -1,6 +1,11 @@
 import { useCallback, useEffect, useState } from "react";
-import { useAuthenticationConfig } from "../useAuthenticationConfig";
-import { LOGIN_STATUS_FAILED } from "./common/constants";
+import { useAuthenticationConfig } from "../../../../hooks/authentication/config/useAuthenticationConfig";
+import {
+  LOGIN_STATUS_FAILED,
+  LOGIN_STATUS_NOT_STARTED,
+  LOGIN_STATUS_PENDING,
+  TERRA_SERVICE_ID,
+} from "./common/constants";
 import {
   LoginResponseError,
   LoginStatus,
@@ -10,6 +15,9 @@ import {
   getAuthenticationRequestOptions,
   initLoginStatus,
 } from "./common/utils";
+import { getServiceEndpoint } from "./utils";
+
+const ENDPOINT_ID = "profile";
 
 type Status = LoginStatus<TerraResponse>;
 
@@ -37,16 +45,20 @@ interface TerraResponseUserInfo {
  * @returns Terra profile login status.
  */
 export const useFetchTerraProfile = (token?: string): Status => {
-  const authenticationConfig = useAuthenticationConfig();
-  const { terraAuthConfig: { terraProfileEndpoint: endpoint } = {} } =
-    authenticationConfig;
+  const { services } = useAuthenticationConfig() || {};
+  const endpoint = getServiceEndpoint(services, TERRA_SERVICE_ID, ENDPOINT_ID);
   const [loginStatus, setLoginStatus] = useState<Status>(
     initLoginStatus(endpoint) as Status
   );
 
   // Fetch Terra profile.
   const fetchEndpointData = useCallback(
-    (endpoint: string, accessToken: string): void => {
+    (endpoint: string, accessToken?: string): void => {
+      if (!accessToken) {
+        setLoginStatus(LOGIN_STATUS_NOT_STARTED as Status);
+        return;
+      }
+      setLoginStatus(LOGIN_STATUS_PENDING as Status);
       fetch(endpoint, getAuthenticationRequestOptions(accessToken))
         .then((response) => response.json())
         .then((response: TerraResponse | LoginResponseError) => {
@@ -71,7 +83,6 @@ export const useFetchTerraProfile = (token?: string): Status => {
 
   // Fetches Terra profile.
   useEffect(() => {
-    if (!token) return;
     if (!endpoint) return;
     fetchEndpointData(endpoint, token);
   }, [endpoint, fetchEndpointData, token]);

package/src/{hooks/useAuthentication → providers/authentication/terra/hooks}/useFetchTerraTermsOfService.ts

@@ -1,6 +1,11 @@
 import { useCallback, useEffect, useState } from "react";
-import { useAuthenticationConfig } from "../useAuthenticationConfig";
-import { LOGIN_STATUS_FAILED } from "./common/constants";
+import { useAuthenticationConfig } from "../../../../hooks/authentication/config/useAuthenticationConfig";
+import {
+  LOGIN_STATUS_FAILED,
+  LOGIN_STATUS_NOT_STARTED,
+  LOGIN_STATUS_PENDING,
+  TERRA_SERVICE_ID,
+} from "./common/constants";
 import {
   LoginResponseError,
   LoginStatus,
@@ -10,6 +15,9 @@ import {
   getAuthenticationRequestOptions,
   initLoginStatus,
 } from "./common/utils";
+import { getServiceEndpoint } from "./utils";
+
+const ENDPOINT_ID = "tos";
 
 type Status = LoginStatus<TerraTermsOfServiceResponse>;
 
@@ -26,16 +34,20 @@ export interface TerraTermsOfServiceResponse {
  * @returns Terra terms of service login status.
  */
 export const useFetchTerraTermsOfService = (token?: string): Status => {
-  const authenticationConfig = useAuthenticationConfig();
-  const { terraAuthConfig: { termsOfServiceEndpoint: endpoint } = {} } =
-    authenticationConfig;
+  const { services } = useAuthenticationConfig() || {};
+  const endpoint = getServiceEndpoint(services, TERRA_SERVICE_ID, ENDPOINT_ID);
   const [loginStatus, setLoginStatus] = useState<Status>(
     initLoginStatus(endpoint) as Status
   );
 
   // Fetch Terra terms of service.
   const fetchEndpointData = useCallback(
-    (endpoint: string, accessToken: string): void => {
+    (endpoint: string, accessToken?: string): void => {
+      if (!accessToken) {
+        setLoginStatus(LOGIN_STATUS_NOT_STARTED as Status);
+        return;
+      }
+      setLoginStatus(LOGIN_STATUS_PENDING as Status);
       fetch(endpoint, getAuthenticationRequestOptions(accessToken))
         .then((response) => response.json())
         .then((response: LoginResponseError | TerraTermsOfServiceResponse) => {
@@ -60,7 +72,6 @@ export const useFetchTerraTermsOfService = (token?: string): Status => {
 
   // Fetches Terra terms of service.
   useEffect(() => {
-    if (!token) return;
     if (!endpoint) return;
     fetchEndpointData(endpoint, token);
   }, [endpoint, fetchEndpointData, token]);

package/src/providers/authentication/terra/hooks/utils.ts

@@ -0,0 +1,29 @@
+import { AuthService } from "../../../../config/entities";
+
+/**
+ * Returns service endpoint.
+ * @param services - Services.
+ * @param serviceId - Service ID.
+ * @param endpointId - Endpoint ID.
+ * @returns Service endpoint.
+ */
+export function getServiceEndpoint(
+  services: AuthService[] | undefined,
+  serviceId: string,
+  endpointId: string
+): string | undefined {
+  return findService(services, serviceId)?.endpoint[endpointId];
+}
+
+/**
+ * Find a service by service ID.
+ * @param services - Services.
+ * @param serviceId - Service ID.
+ * @returns Service.
+ */
+export function findService(
+  services: AuthService[] | undefined,
+  serviceId: string
+): AuthService | undefined {
+  return services?.find(({ id }) => id === serviceId);
+}

package/src/providers/authentication/terra/provider.tsx

@@ -0,0 +1,60 @@
+import React, { useEffect } from "react";
+import { authComplete } from "../auth/dispatch";
+import { useAuth } from "../auth/hook";
+import { authenticationComplete } from "../authentication/dispatch";
+import { useAuthentication } from "../authentication/hook";
+import { updateCredentials } from "../credentials/dispatch";
+import { useCredentials } from "../credentials/hook";
+import { TerraProfileContext } from "./context";
+import { useFetchProfiles } from "./hooks/useFetchProfiles";
+import { TerraProfileProviderProps } from "./types";
+
+export function TerraProfileProvider({
+  children,
+  token,
+}: TerraProfileProviderProps): JSX.Element {
+  const { authDispatch } = useAuth();
+  const { authenticationDispatch } = useAuthentication();
+  const { credentialsDispatch } = useCredentials();
+  const {
+    isAuthenticated,
+    isComplete,
+    isProfileActive,
+    terraNIHProfileLoginStatus,
+    terraProfileLoginStatus,
+    terraTOSLoginStatus,
+  } = useFetchProfiles(token);
+
+  useEffect(() => {
+    // Dispatch only when terra profile is available:
+    // - Login errors are managed by the login service.
+    // - Logout operations handle resetting credentials, authentication and auth state.
+    if (!isComplete) return; // Terra profile status is still "PENDING".
+    // Release authentication only when terra profile status is either "AUTHENTICATED" or "UNAUTHENTICATED" i.e. not "PENDING".
+    authenticationDispatch?.(authenticationComplete()); // Authentication `status` is "SETTLED".
+    authDispatch?.(authComplete({ isAuthenticated })); // Auth `status` is "SETTLED", and `isAuthenticated` is either "true" or "false".
+    if (!isProfileActive) return;
+    // Release credentials only when terra profile is "AUTHENTICATED".
+    credentialsDispatch?.(updateCredentials(token));
+  }, [
+    authDispatch,
+    authenticationDispatch,
+    credentialsDispatch,
+    isAuthenticated,
+    isComplete,
+    isProfileActive,
+    token,
+  ]);
+
+  return (
+    <TerraProfileContext.Provider
+      value={{
+        terraNIHProfileLoginStatus,
+        terraProfileLoginStatus,
+        terraTOSLoginStatus,
+      }}
+    >
+      {children}
+    </TerraProfileContext.Provider>
+  );
+}

package/src/providers/authentication/terra/types.ts

@@ -0,0 +1,23 @@
+import { ReactNode } from "react";
+import { TokenState } from "../token/types";
+import { LoginStatus } from "./hooks/common/entities";
+import { TerraNIHResponse } from "./hooks/useFetchTerraNIHProfile";
+import { TerraResponse } from "./hooks/useFetchTerraProfile";
+import { TerraTermsOfServiceResponse } from "./hooks/useFetchTerraTermsOfService";
+
+export enum TERRA_PROFILE_STATUS {
+  AUTHENTICATED = "AUTHENTICATED",
+  PENDING = "PENDING",
+  UNAUTHENTICATED = "UNAUTHENTICATED",
+}
+
+export interface TerraProfileProviderProps {
+  children: ReactNode;
+  token: TokenState["token"];
+}
+
+export interface TerraProfileContextProps {
+  terraNIHProfileLoginStatus: LoginStatus<TerraNIHResponse>;
+  terraProfileLoginStatus: LoginStatus<TerraResponse>;
+  terraTOSLoginStatus: LoginStatus<TerraTermsOfServiceResponse>;
+}

package/src/providers/authentication/terra/utils.ts

@@ -0,0 +1,49 @@
+import { LoginStatus, REQUEST_STATUS } from "./hooks/common/entities";
+import { TerraNIHResponse } from "./hooks/useFetchTerraNIHProfile";
+import { TerraResponse } from "./hooks/useFetchTerraProfile";
+import { TerraTermsOfServiceResponse } from "./hooks/useFetchTerraTermsOfService";
+import { TERRA_PROFILE_STATUS } from "./types";
+
+/**
+ * Determines the status of a user based on authentication and Terra service statuses.
+ * **Logic:**
+ * - **Pending** if the user is not authenticated.
+ * - **Pending** if any supported Terra service request is not started or pending.
+ * - **Unauthenticated** if the Terra profile is supported but the Terms of Service have not been accepted.
+ * - **Authenticated** in all other cases.
+ * @param isUserAuthenticated - User authentication status.
+ * @param terraNIHProfileLoginStatus - Terra NIH profile login status.
+ * @param terraProfileLoginStatus - Terra profile login status.
+ * @param terraTOSLoginStatus - Terra terms of service login status.
+ * @returns Terra profile status.
+ */
+export function getProfileStatus(
+  isUserAuthenticated: boolean,
+  terraNIHProfileLoginStatus: LoginStatus<TerraNIHResponse>,
+  terraProfileLoginStatus: LoginStatus<TerraResponse>,
+  terraTOSLoginStatus: LoginStatus<TerraTermsOfServiceResponse>
+): TERRA_PROFILE_STATUS {
+  if (!isUserAuthenticated) return TERRA_PROFILE_STATUS.PENDING;
+
+  // Check if any supported Terra service request is not started or pending.
+  const terraServices = [
+    terraNIHProfileLoginStatus,
+    terraProfileLoginStatus,
+    terraTOSLoginStatus,
+  ];
+  const isAnyServicePending = terraServices.some(
+    ({ isSupported, requestStatus }) =>
+      isSupported &&
+      (requestStatus === REQUEST_STATUS.NOT_STARTED ||
+        requestStatus === REQUEST_STATUS.PENDING)
+  );
+  if (isAnyServicePending) return TERRA_PROFILE_STATUS.PENDING;
+
+  // If Terra profile is supported but Terms of Service not accepted.
+  if (terraProfileLoginStatus.isSupported && !terraTOSLoginStatus.isSuccess) {
+    return TERRA_PROFILE_STATUS.UNAUTHENTICATED;
+  }
+
+  // Authenticated in all other cases.
+  return TERRA_PROFILE_STATUS.AUTHENTICATED;
+}

package/src/providers/authentication/token/constants.ts

@@ -0,0 +1,6 @@
+import { TokenState } from "./types";
+
+export const DEFAULT_TOKEN_STATE: TokenState = {
+  providerId: undefined,
+  token: undefined,
+};

package/src/providers/authentication/token/dispatch.ts

@@ -0,0 +1,29 @@
+import {
+  ResetStateAction,
+  TokenActionKind,
+  UpdateTokenAction,
+  UpdateTokenPayload,
+} from "./types";
+
+/**
+ * Reset state action.
+ * @returns Action.
+ */
+export function resetState(): ResetStateAction {
+  return {
+    payload: undefined,
+    type: TokenActionKind.ResetState,
+  };
+}
+
+/**
+ * Update token action.
+ * @param payload - Payload.
+ * @returns Action.
+ */
+export function updateToken(payload: UpdateTokenPayload): UpdateTokenAction {
+  return {
+    payload,
+    type: TokenActionKind.UpdateToken,
+  };
+}

package/src/providers/authentication/token/reducer.ts

@@ -0,0 +1,26 @@
+import { DEFAULT_TOKEN_STATE } from "./constants";
+import { TokenAction, TokenActionKind, TokenState } from "./types";
+
+/**
+ * Token reducer.
+ * @param state - State.
+ * @param action - Action.
+ * @returns state.
+ */
+export function tokenReducer(
+  state: TokenState,
+  action: TokenAction
+): TokenState {
+  const { payload, type } = action;
+  switch (type) {
+    case TokenActionKind.ResetState:
+      return DEFAULT_TOKEN_STATE;
+    case TokenActionKind.UpdateToken:
+      return {
+        ...state,
+        ...payload,
+      };
+    default:
+      return state;
+  }
+}