@databiosphere/findable-ui 19.0.0 → 20.0.0

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;
+  }
+}

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

@@ -0,0 +1,36 @@
+import { Dispatch } from "react";
+import { ProviderId } from "../common/types";
+
+export interface ResetStateAction {
+  payload: ResetStatePayload;
+  type: TokenActionKind.ResetState;
+}
+
+export type ResetStatePayload = undefined;
+
+export type TokenAction = ResetStateAction | UpdateTokenAction;
+
+export enum TokenActionKind {
+  ResetState = "RESET_TOKEN",
+  UpdateToken = "UPDATE_TOKEN",
+}
+
+export interface TokenContextProps {
+  tokenDispatch: Dispatch<TokenAction> | null;
+  tokenState: TokenState;
+}
+
+export interface TokenState {
+  providerId: ProviderId | undefined;
+  token: string | undefined;
+}
+
+export interface UpdateTokenAction {
+  payload: UpdateTokenPayload;
+  type: TokenActionKind.UpdateToken;
+}
+
+export interface UpdateTokenPayload {
+  providerId: ProviderId | undefined;
+  token: string | undefined;
+}

package/src/providers/exploreState.tsx

@@ -12,7 +12,7 @@ import { AzulSearchIndex } from "../apis/azul/common/entities";
 import { SelectCategoryView, SelectedFilter } from "../common/entities";
 import { RowPreviewState } from "../components/Table/features/RowPreview/entities";
 import { CategoryGroup, SiteConfig } from "../config/entities";
-import { useAuthentication } from "../hooks/useAuthentication/useAuthentication";
+import { useToken } from "../hooks/authentication/token/useToken";
 import {
   buildCategoryViews,
   buildNextFilterState,
@@ -170,7 +170,7 @@ export function ExploreStateProvider({
   const { config, defaultEntityListType } = useConfig();
   const { decodedCatalogParam, decodedFeatureFlagParam, decodedFilterParam } =
     useURLFilterParams();
-  const { isEnabled: isAuthEnabled, token } = useAuthentication();
+  const { token } = useToken();
   const entityList = entityListType || defaultEntityListType;
   const [initializerArg] = useState(() =>
     initReducerArguments(
@@ -198,12 +198,11 @@ export function ExploreStateProvider({
 
   // Reset explore response when token changes.
   useEffect(() => {
-    if (!isAuthEnabled) return;
     exploreDispatch({
       payload: undefined,
       type: ExploreActionKind.ResetExploreResponse,
     });
-  }, [exploreDispatch, isAuthEnabled, token]);
+  }, [exploreDispatch, token]);
 
   return (
     <ExploreStateContext.Provider value={exploreContextValue}>

package/src/providers/googleSignInAuthentication/common/types.ts

@@ -0,0 +1,28 @@
+import { Dispatch } from "react";
+import { AuthAction, AuthContextProps } from "../../authentication/auth/types";
+import {
+  AuthenticationAction,
+  AuthenticationContextProps,
+} from "../../authentication/authentication/types";
+import {
+  CredentialsAction,
+  CredentialsContextProps,
+} from "../../authentication/credentials/types";
+import {
+  TokenAction,
+  TokenContextProps,
+} from "../../authentication/token/types";
+
+export interface SessionReducer {
+  authenticationReducer: AuthenticationContextProps;
+  authReducer: Omit<AuthContextProps, "service">;
+  credentialsReducer: CredentialsContextProps;
+  tokenReducer: TokenContextProps;
+}
+
+export interface SessionDispatch {
+  authDispatch: Dispatch<AuthAction> | null;
+  authenticationDispatch: Dispatch<AuthenticationAction> | null;
+  credentialsDispatch: Dispatch<CredentialsAction> | null;
+  tokenDispatch: Dispatch<TokenAction> | null;
+}

package/src/providers/googleSignInAuthentication/constants.ts

@@ -0,0 +1,17 @@
+import { DEFAULT_AUTH_STATE } from "../authentication/auth/constants";
+import { AUTH_STATUS, AuthState } from "../authentication/auth/types";
+import { DEFAULT_AUTHENTICATION_STATE } from "../authentication/authentication/constants";
+import {
+  AUTHENTICATION_STATUS,
+  AuthenticationState,
+} from "../authentication/authentication/types";
+
+export const AUTH_STATE: AuthState = {
+  ...DEFAULT_AUTH_STATE,
+  status: AUTH_STATUS.SETTLED,
+};
+
+export const AUTHENTICATION_STATE: AuthenticationState = {
+  ...DEFAULT_AUTHENTICATION_STATE,
+  status: AUTHENTICATION_STATUS.SETTLED,
+};

package/src/providers/googleSignInAuthentication/hooks/useGoogleSignInService.ts

@@ -0,0 +1,53 @@
+import { useRouter } from "next/router";
+import { useCallback } from "react";
+import { useProviders } from "../../../hooks/authentication/providers/useProviders";
+import { Service } from "../../authentication/auth/types";
+import { ProviderId } from "../../authentication/common/types";
+import { SessionReducer } from "../common/types";
+import { service } from "../service/service";
+
+export const useGoogleSignInService = (reducer: SessionReducer): Service => {
+  const { findProvider } = useProviders();
+  const { basePath } = useRouter();
+  const {
+    authenticationReducer: { authenticationDispatch },
+    authReducer: { authDispatch },
+    credentialsReducer: { credentialsDispatch },
+    tokenReducer: { tokenDispatch },
+  } = reducer;
+
+  const onLogin = useCallback(
+    (providerId: ProviderId) => {
+      const provider = findProvider(providerId);
+      if (!provider) return;
+      service.login(provider, {
+        authDispatch,
+        authenticationDispatch,
+        tokenDispatch,
+      });
+    },
+    [authDispatch, authenticationDispatch, findProvider, tokenDispatch]
+  );
+
+  const onLogout = useCallback(
+    (options?: { callbackUrl?: string }) => {
+      service.logout({
+        authDispatch,
+        authenticationDispatch,
+        credentialsDispatch,
+        tokenDispatch,
+      });
+      // Request page reload, ensuring that the entity detail page is re-initialized with the correct state and associated data.
+      location.href = options?.callbackUrl || basePath;
+    },
+    [
+      authDispatch,
+      authenticationDispatch,
+      basePath,
+      credentialsDispatch,
+      tokenDispatch,
+    ]
+  );
+
+  return { requestLogin: onLogin, requestLogout: onLogout };
+};

package/src/providers/googleSignInAuthentication/profile/types.ts

@@ -0,0 +1,15 @@
+export interface GoogleProfile {
+  email: string;
+  email_verified: boolean;
+  family_name: string;
+  given_name: string;
+  hd: string;
+  locale: string;
+  name: string;
+  picture: string;
+  sub: string;
+}
+
+export interface TokenSetParameters {
+  access_token: string;
+}

package/src/providers/googleSignInAuthentication/profile/utils.ts

@@ -0,0 +1,29 @@
+import { UserProfile } from "../../authentication/authentication/types";
+import { GOOGLE_SIGN_IN_PROVIDER_ID } from "../service/constants";
+import { GoogleProfile } from "./types";
+
+/**
+ * Returns full name, from given and family name.
+ * @param profile - Google response.
+ * @returns full name.
+ */
+function getFullName(profile: GoogleProfile): string {
+  const { family_name: lastName = "", given_name: firstName = "" } = profile;
+  return `${firstName} ${lastName}`.trim();
+}
+
+/**
+ * Returns user profile from google response.
+ * @param profile - Google response.
+ * @returns user profile.
+ */
+export function mapProfile(profile: GoogleProfile): UserProfile {
+  const { email, picture: image } = profile;
+  const name = getFullName(profile);
+  return {
+    email,
+    id: GOOGLE_SIGN_IN_PROVIDER_ID,
+    image,
+    name,
+  };
+}