@databiosphere/findable-ui 19.0.0 → 21.0.0

package/src/providers/nextAuthAuthentication/provider.tsx

@@ -0,0 +1,42 @@
+import { SessionProvider } from "next-auth/react";
+import React from "react";
+import { SessionController } from "../../components/Authentication/components/SessionController/components/NextSessionController/SessionController";
+import { useAuthReducer } from "../../hooks/authentication/auth/useAuthReducer";
+import { useAuthenticationReducer } from "../../hooks/authentication/authentication/useAuthenticationReducer";
+import { useSessionCallbackUrl } from "../../hooks/authentication/session/useSessionCallbackUrl";
+import { useSessionIdleTimer } from "../../hooks/authentication/session/useSessionIdleTimer";
+import { AuthContext } from "../authentication/auth/context";
+import { AuthenticationContext } from "../authentication/authentication/context";
+import { useNextAuthService } from "./hooks/useNextAuthService";
+import { NextAuthAuthenticationProviderProps } from "./types";
+
+export function NextAuthAuthenticationProvider({
+  children,
+  refetchInterval = 0,
+  session,
+  timeout,
+}: NextAuthAuthenticationProviderProps): JSX.Element {
+  const authReducer = useAuthReducer();
+  const authenticationReducer = useAuthenticationReducer();
+  const service = useNextAuthService();
+  const { authDispatch, authState } = authReducer;
+  const { isAuthenticated } = authState;
+  const { callbackUrl } = useSessionCallbackUrl();
+  useSessionIdleTimer({
+    crossTab: true,
+    disabled: !isAuthenticated,
+    onIdle: () => {
+      service.requestLogout({ callbackUrl, redirect: true });
+    },
+    timeout,
+  });
+  return (
+    <SessionProvider session={session} refetchInterval={refetchInterval / 1000}>
+      <AuthenticationContext.Provider value={authenticationReducer}>
+        <AuthContext.Provider value={{ authDispatch, authState, service }}>
+          <SessionController>{children}</SessionController>
+        </AuthContext.Provider>
+      </AuthenticationContext.Provider>
+    </SessionProvider>
+  );
+}

package/src/providers/nextAuthAuthentication/service/service.ts

@@ -0,0 +1,14 @@
+import { signIn, SignInOptions, signOut, SignOutParams } from "next-auth/react";
+import { ProviderId } from "../../authentication/common/types";
+
+export const service = {
+  login: (providerId: ProviderId, options?: SignInOptions): void => {
+    signIn(providerId, options).catch((e) => console.error(e));
+  },
+  logout: (options?: SignOutParams<boolean>): void => {
+    signOut({
+      callbackUrl: options?.callbackUrl,
+      redirect: options?.redirect || false,
+    }).catch((e) => console.error(e));
+  },
+};

package/src/providers/nextAuthAuthentication/types.ts

@@ -0,0 +1,9 @@
+import { Session } from "next-auth";
+import { ReactNode } from "react";
+
+export interface NextAuthAuthenticationProviderProps {
+  children: ReactNode | ReactNode[];
+  refetchInterval?: number;
+  session?: Session | null;
+  timeout?: number;
+}

package/src/routes/constants.ts

@@ -0,0 +1,3 @@
+export const ROUTE = {
+  LOGIN: "/login",
+};

package/src/styles/common/mui/button.ts

@@ -0,0 +1,20 @@
+import { ButtonProps } from "@mui/material";
+
+export const COLOR: Record<string, ButtonProps["color"]> = {
+  ERROR: "error",
+  INFO: "info",
+  INHERIT: "inherit",
+  PRIMARY: "primary",
+  SECONDARY: "secondary",
+  SUCCESS: "success",
+  WARNING: "warning",
+};
+
+export const VARIANT: Record<string, ButtonProps["variant"]> = {
+  ACTIVE_NAV: "activeNav",
+  BACK_NAV: "backNav",
+  CONTAINED: "contained",
+  NAV: "nav",
+  OUTLINED: "outlined",
+  TEXT: "text",
+};

package/src/styles/common/mui/paper.ts

@@ -0,0 +1,11 @@
+import { PaperProps } from "@mui/material";
+
+export const VARIANT: Record<string, PaperProps["variant"]> = {
+  ELEVATION: "elevation",
+  FOOTER: "footer",
+  MENU: "menu",
+  OUTLINED: "outlined",
+  PANEL: "panel",
+  SEARCH_BAR: "searchbar",
+  TABLE: "table",
+};

package/src/styles/common/mui/popover.ts

@@ -0,0 +1,19 @@
+import { PopoverOrigin } from "@mui/material";
+
+export const POPOVER_ORIGIN_HORIZONTAL: Record<
+  string,
+  PopoverOrigin["horizontal"]
+> = {
+  CENTER: "center",
+  LEFT: "left",
+  RIGHT: "right",
+};
+
+export const POPOVER_ORIGIN_VERTICAL: Record<
+  string,
+  PopoverOrigin["vertical"]
+> = {
+  BOTTOM: "bottom",
+  CENTER: "center",
+  TOP: "top",
+};

package/src/theme/common/entities.ts

@@ -0,0 +1,7 @@
+export interface BaseComponentProps {
+  className?: string;
+}
+
+export interface TrackingComponentProps {
+  trackingId?: string;
+}

package/src/views/LoginView/loginView.tsx

@@ -1,18 +1,24 @@
+import { ClientSafeProvider } from "next-auth/react";
 import React from "react";
 import { Login } from "../../components/Login/login";
-import { useAuthenticationConfig } from "../../hooks/useAuthenticationConfig";
+import { useAuthenticationConfig } from "../../hooks/authentication/config/useAuthenticationConfig";
 
-export const LoginView = (): JSX.Element => {
-  const { googleGISAuthConfig, termsOfService, text, title, warning } =
-    useAuthenticationConfig();
+export interface LoginViewProps {
+  providers?: ClientSafeProvider[];
+}
 
+export const LoginView = ({
+  providers,
+}: LoginViewProps): JSX.Element | null => {
+  const authConfig = useAuthenticationConfig();
+  if (!authConfig) return null;
   return (
     <Login
-      isGoogle={!!googleGISAuthConfig}
-      termsOfService={termsOfService}
-      text={text}
-      title={title}
-      warning={warning}
+      providers={providers || authConfig.providers}
+      termsOfService={authConfig.termsOfService}
+      text={authConfig.text}
+      title={authConfig.title}
+      warning={authConfig.warning}
     />
   );
 };

package/tests/getProfileStatus.test.ts

@@ -0,0 +1,290 @@
+import {
+  LoginStatus,
+  REQUEST_STATUS,
+} from "../src/providers/authentication/terra/hooks/common/entities";
+import { TerraNIHResponse } from "../src/providers/authentication/terra/hooks/useFetchTerraNIHProfile";
+import { TerraResponse } from "../src/providers/authentication/terra/hooks/useFetchTerraProfile";
+import { TerraTermsOfServiceResponse } from "../src/providers/authentication/terra/hooks/useFetchTerraTermsOfService";
+import { TERRA_PROFILE_STATUS } from "../src/providers/authentication/terra/types";
+import { getProfileStatus } from "../src/providers/authentication/terra/utils";
+
+const LOGIN_STATUS_NIH_COMPLETED: LoginStatus<TerraNIHResponse> = {
+  isSuccess: true,
+  isSupported: true,
+  requestStatus: REQUEST_STATUS.COMPLETED,
+  response: undefined,
+};
+
+const LOGIN_STATUS_TERRA_COMPLETED: LoginStatus<TerraResponse> = {
+  isSuccess: true,
+  isSupported: true,
+  requestStatus: REQUEST_STATUS.COMPLETED,
+  response: undefined,
+};
+
+const LOGIN_STATUS_TOS_COMPLETED: LoginStatus<TerraTermsOfServiceResponse> = {
+  isSuccess: true,
+  isSupported: true,
+  requestStatus: REQUEST_STATUS.COMPLETED,
+  response: undefined,
+};
+
+const LOGIN_STATUS_TOS_COMPLETED_UNSUCCESSFUL: LoginStatus<TerraTermsOfServiceResponse> =
+  {
+    isSuccess: false,
+    isSupported: true,
+    requestStatus: REQUEST_STATUS.COMPLETED,
+    response: undefined,
+  };
+
+const LOGIN_STATUS_NIH_NOT_STARTED: LoginStatus<TerraNIHResponse> = {
+  isSuccess: false,
+  isSupported: true,
+  requestStatus: REQUEST_STATUS.NOT_STARTED,
+  response: undefined,
+};
+
+const LOGIN_STATUS_TERRA_NOT_STARTED: LoginStatus<TerraResponse> = {
+  isSuccess: false,
+  isSupported: true,
+  requestStatus: REQUEST_STATUS.NOT_STARTED,
+  response: undefined,
+};
+
+const LOGIN_STATUS_TOS_NOT_STARTED: LoginStatus<TerraTermsOfServiceResponse> = {
+  isSuccess: false,
+  isSupported: true,
+  requestStatus: REQUEST_STATUS.NOT_STARTED,
+  response: undefined,
+};
+
+const LOGIN_STATUS_NIH_PENDING: LoginStatus<TerraNIHResponse> = {
+  isSuccess: false,
+  isSupported: true,
+  requestStatus: REQUEST_STATUS.PENDING,
+  response: undefined,
+};
+
+const LOGIN_STATUS_TERRA_PENDING: LoginStatus<TerraResponse> = {
+  isSuccess: false,
+  isSupported: true,
+  requestStatus: REQUEST_STATUS.PENDING,
+  response: undefined,
+};
+
+const LOGIN_STATUS_TOS_PENDING: LoginStatus<TerraTermsOfServiceResponse> = {
+  isSuccess: false,
+  isSupported: true,
+  requestStatus: REQUEST_STATUS.PENDING,
+  response: undefined,
+};
+
+const LOGIN_STATUS_NIH_UNSUPPORTED: LoginStatus<TerraNIHResponse> = {
+  isSuccess: false,
+  isSupported: false,
+  requestStatus: REQUEST_STATUS.NOT_STARTED,
+  response: undefined,
+};
+
+const LOGIN_STATUS_TERRA_UNSUPPORTED: LoginStatus<TerraResponse> = {
+  isSuccess: false,
+  isSupported: false,
+  requestStatus: REQUEST_STATUS.NOT_STARTED,
+  response: undefined,
+};
+
+const LOGIN_STATUS_TOS_UNSUPPORTED: LoginStatus<TerraTermsOfServiceResponse> = {
+  isSuccess: false,
+  isSupported: false,
+  requestStatus: REQUEST_STATUS.NOT_STARTED,
+  response: undefined,
+};
+
+describe("getProfileStatus", () => {
+  test("not authenticated, services not started", () => {
+    expect(
+      getProfileStatus(
+        false,
+        LOGIN_STATUS_NIH_NOT_STARTED,
+        LOGIN_STATUS_TERRA_NOT_STARTED,
+        LOGIN_STATUS_TOS_NOT_STARTED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("not authenticated, services unsupported", () => {
+    expect(
+      getProfileStatus(
+        false,
+        LOGIN_STATUS_NIH_UNSUPPORTED,
+        LOGIN_STATUS_TERRA_UNSUPPORTED,
+        LOGIN_STATUS_TOS_UNSUPPORTED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("not authenticated, services completed", () => {
+    expect(
+      getProfileStatus(
+        false,
+        LOGIN_STATUS_NIH_COMPLETED,
+        LOGIN_STATUS_TERRA_COMPLETED,
+        LOGIN_STATUS_TOS_COMPLETED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("authenticated, services not started", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_NOT_STARTED,
+        LOGIN_STATUS_TERRA_NOT_STARTED,
+        LOGIN_STATUS_TOS_NOT_STARTED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("authenticated, services pending", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_PENDING,
+        LOGIN_STATUS_TERRA_PENDING,
+        LOGIN_STATUS_TOS_PENDING
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("authenticated, nih pending, other services completed", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_PENDING,
+        LOGIN_STATUS_TERRA_COMPLETED,
+        LOGIN_STATUS_TOS_COMPLETED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("authenticated, terra pending, other services completed", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_COMPLETED,
+        LOGIN_STATUS_TERRA_PENDING,
+        LOGIN_STATUS_TOS_COMPLETED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("authenticated, tos pending, other services completed", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_COMPLETED,
+        LOGIN_STATUS_TERRA_COMPLETED,
+        LOGIN_STATUS_TOS_PENDING
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("authenticated, nih completed, terra pending, tos not started", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_COMPLETED,
+        LOGIN_STATUS_TERRA_PENDING,
+        LOGIN_STATUS_TOS_NOT_STARTED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("authenticated, nih not started, terra completed, tos pending", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_NOT_STARTED,
+        LOGIN_STATUS_TERRA_COMPLETED,
+        LOGIN_STATUS_TOS_PENDING
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("authenticated, nih pending, terra not started, tos completed", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_PENDING,
+        LOGIN_STATUS_TERRA_NOT_STARTED,
+        LOGIN_STATUS_TOS_COMPLETED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("authenticated, services unsupported", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_UNSUPPORTED,
+        LOGIN_STATUS_TERRA_UNSUPPORTED,
+        LOGIN_STATUS_TOS_UNSUPPORTED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.AUTHENTICATED);
+  });
+
+  test("authenticated, services completed, tos unsuccessful", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_COMPLETED,
+        LOGIN_STATUS_TERRA_COMPLETED,
+        LOGIN_STATUS_TOS_COMPLETED_UNSUCCESSFUL
+      )
+    ).toBe(TERRA_PROFILE_STATUS.UNAUTHENTICATED);
+  });
+
+  test("authenticated, nih unsupported, terra completed, tos completed unsuccessfully", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_UNSUPPORTED,
+        LOGIN_STATUS_TERRA_COMPLETED,
+        LOGIN_STATUS_TOS_COMPLETED_UNSUCCESSFUL
+      )
+    ).toBe(TERRA_PROFILE_STATUS.UNAUTHENTICATED);
+  });
+
+  test("authenticated, nih unsupported, other services completed", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_UNSUPPORTED,
+        LOGIN_STATUS_TERRA_COMPLETED,
+        LOGIN_STATUS_TOS_COMPLETED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.AUTHENTICATED);
+  });
+
+  test("authenticated, terra completed, other services unsupported", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_UNSUPPORTED,
+        LOGIN_STATUS_TERRA_COMPLETED,
+        LOGIN_STATUS_TOS_UNSUPPORTED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.UNAUTHENTICATED);
+  });
+
+  test("authenticated, services completed", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_COMPLETED,
+        LOGIN_STATUS_TERRA_COMPLETED,
+        LOGIN_STATUS_TOS_COMPLETED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.AUTHENTICATED);
+  });
+});

package/tests/terraProfileProvider.test.tsx

@@ -0,0 +1,121 @@
+import { jest } from "@jest/globals";
+import { render } from "@testing-library/react";
+import React from "react";
+import { DEFAULT_AUTHENTICATION_STATE } from "../src/providers/authentication/authentication/constants";
+import { authenticationComplete } from "../src/providers/authentication/authentication/dispatch";
+import { DEFAULT_CREDENTIALS_STATE } from "../src/providers/authentication/credentials/constants";
+import { updateCredentials } from "../src/providers/authentication/credentials/dispatch";
+
+const TOKEN = "test-token";
+
+const PROFILE_PENDING = {
+  isComplete: false,
+  isProfileActive: false,
+};
+
+const PROFILE_SETTLED_ACTIVE = {
+  isComplete: true,
+  isProfileActive: true,
+};
+
+const PROFILE_SETTLED_INACTIVE = {
+  isComplete: true,
+  isProfileActive: false,
+};
+
+jest.unstable_mockModule(
+  "../src/providers/authentication/authentication/hook",
+  () => ({
+    useAuthentication: jest.fn(),
+  })
+);
+jest.unstable_mockModule(
+  "../src/providers/authentication/credentials/hook",
+  () => ({
+    useCredentials: jest.fn(),
+  })
+);
+jest.unstable_mockModule(
+  "../src/providers/authentication/terra/hooks/useFetchProfiles",
+  () => ({
+    useFetchProfiles: jest.fn(),
+  })
+);
+
+const { useAuthentication } = await import(
+  "../src/providers/authentication/authentication/hook"
+);
+const { useCredentials } = await import(
+  "../src/providers/authentication/credentials/hook"
+);
+const { useFetchProfiles } = await import(
+  "../src/providers/authentication/terra/hooks/useFetchProfiles"
+);
+const { TerraProfileProvider } = await import(
+  "../src/providers/authentication/terra/provider"
+);
+
+const MOCK_AUTHENTICATION_DISPATCH = jest.fn();
+const MOCK_CREDENTIALS_DISPATCH = jest.fn();
+const MOCK_USE_AUTHENTICATION = useAuthentication as jest.MockedFunction<
+  typeof useAuthentication
+>;
+const MOCK_USE_CREDENTIALS = useCredentials as jest.MockedFunction<
+  typeof useCredentials
+>;
+const MOCK_USE_FETCH_PROFILES = useFetchProfiles as jest.MockedFunction<
+  () => Partial<ReturnType<typeof useFetchProfiles>>
+>;
+
+describe("TerraProfileProvider", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    MOCK_USE_AUTHENTICATION.mockReturnValue({
+      authenticationDispatch: MOCK_AUTHENTICATION_DISPATCH,
+      authenticationState: DEFAULT_AUTHENTICATION_STATE,
+    });
+    MOCK_USE_CREDENTIALS.mockReturnValue({
+      credentialsDispatch: MOCK_CREDENTIALS_DISPATCH,
+      credentialsState: DEFAULT_CREDENTIALS_STATE,
+    });
+    MOCK_USE_FETCH_PROFILES.mockReturnValue(PROFILE_PENDING);
+  });
+
+  it("does not dispatch actions when terra profile is incomplete", () => {
+    render(
+      <TerraProfileProvider token={TOKEN}>
+        <div>Child Component</div>
+      </TerraProfileProvider>
+    );
+    expect(MOCK_AUTHENTICATION_DISPATCH).not.toHaveBeenCalled();
+    expect(MOCK_CREDENTIALS_DISPATCH).not.toHaveBeenCalled();
+  });
+
+  it("calls authenticationComplete dispatch when terra profile is SETTLED and INACTIVE", () => {
+    MOCK_USE_FETCH_PROFILES.mockReturnValue(PROFILE_SETTLED_INACTIVE);
+    render(
+      <TerraProfileProvider token={TOKEN}>
+        <div>Child Component</div>
+      </TerraProfileProvider>
+    );
+    expect(MOCK_AUTHENTICATION_DISPATCH).toHaveBeenCalledWith(
+      authenticationComplete()
+    );
+    expect(MOCK_CREDENTIALS_DISPATCH).not.toHaveBeenCalled();
+  });
+
+  it("dispatches authenticationComplete and updateCredentials when terra profile is SETTLED and ACTIVE", () => {
+    MOCK_USE_FETCH_PROFILES.mockReturnValue(PROFILE_SETTLED_ACTIVE);
+    render(
+      <TerraProfileProvider token={TOKEN}>
+        <div>Child Component</div>
+      </TerraProfileProvider>
+    );
+    expect(MOCK_AUTHENTICATION_DISPATCH).toHaveBeenCalledWith(
+      authenticationComplete()
+    );
+    expect(MOCK_CREDENTIALS_DISPATCH).toHaveBeenCalledWith(
+      updateCredentials(TOKEN)
+    );
+  });
+});

package/tests/transformRoute.test.ts

@@ -0,0 +1,21 @@
+import { transformRoute } from "../src/hooks/authentication/session/useSessionActive";
+
+describe("transformRoute", () => {
+  it("should return the first non-login route without the inactivity param", () => {
+    const routes = ["/login", "/route1?inactivityTimeout=true", "/route2"];
+    const result = transformRoute(routes);
+    expect(result).toBe("/route1");
+  });
+
+  it("should remove the inactivity param from the route", () => {
+    const routes = ["/route1?inactivityTimeout=true"];
+    const result = transformRoute(routes);
+    expect(result).toBe("/route1");
+  });
+
+  it("should return undefined if all routes are login routes", () => {
+    const routes = ["/login"];
+    const result = transformRoute(routes);
+    expect(result).toBeUndefined();
+  });
+});