@bigbinary/neeto-commons-rn 1.8.5 → 2.0.2

package/src/helpers/scale.ts

@@ -0,0 +1,4 @@
+import { moderateScale as baseModerateScale } from "react-native-size-matters";
+
+export const moderateScale = (size: number, factor?: number) =>
+  Math.round(baseModerateScale(size, factor));

package/src/helpers/utils.ts

@@ -0,0 +1,68 @@
+import { Linking } from "react-native";
+
+import { isNotPresent } from "@bigbinary/neeto-cist";
+import { equals, intersection } from "ramda";
+import Config from "react-native-config";
+
+// eslint-disable-next-line no-console
+const logError = (error: unknown) => console.error("Error in utils.js:", error);
+
+export const toTitleCase = (str: string) =>
+  `${str.charAt(0).toUpperCase()}${str.substr(1).toLowerCase()}`;
+
+export const openDeepLinkingUrl = async (url?: string | null) => {
+  if (!url) return;
+
+  try {
+    const scheme = `${Config.URL_SCHEME}://`;
+    let urlToOpen;
+
+    if (url.startsWith(scheme)) {
+      // Already using the custom scheme; don't touch it — replacing would
+      // corrupt web URLs embedded in its query params.
+      urlToOpen = url;
+    } else {
+      // Swap the web origin for the custom scheme. Host ends at "/", "?" or
+      // "#" so root URLs without a trailing slash keep their query string.
+      const domainRegex = /http[s]?:\/\/?[^/\s?#]+\/?/;
+      urlToOpen = url.replace(domainRegex, scheme);
+    }
+
+    // openURL rejects (instead of throwing) when the OS refuses the URL —
+    // e.g. iOS rejects while the app is backgrounded. An unhandled rejection
+    // here surfaces as a Bugsnag "Unable to open URL" error in every host app.
+    await Linking.openURL(urlToOpen);
+  } catch (error) {
+    logError(error);
+  }
+};
+
+export const debounce = <TArgs extends unknown[]>(
+  func: (...args: TArgs) => void,
+  delay = 300
+) => {
+  let timer: ReturnType<typeof setTimeout>;
+
+  return (...args: TArgs) => {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      // The previous `func.apply(this, args)` passed the module scope's
+      // `this`, which is always undefined here — the same receiver a plain
+      // call gives.
+      func(...args);
+    }, delay);
+  };
+};
+
+export const hasPermission = (
+  allPermissions: string[] = [],
+  requiredPermissions?: string | string[]
+) => {
+  if (isNotPresent(requiredPermissions)) return true;
+
+  const permissions = Array.isArray(requiredPermissions)
+    ? requiredPermissions
+    : [requiredPermissions as string];
+
+  return equals(intersection(allPermissions, permissions), permissions);
+};

package/src/hooks/index.ts

@@ -0,0 +1,2 @@
+export { useLocalization } from "../contexts/localization";
+export { usePushNotificationPermissions } from "./usePushNotificationPermissions";

package/src/hooks/query/queryKeys.ts

@@ -0,0 +1,8 @@
+export const queryKeys = {
+  APP_VERSION: "APP_VERSION",
+  PROFILE: "PROFILE",
+  NOTIFICATIONS: "NOTIFICATIONS",
+  TEAM_MEMBERS: "TEAM_MEMBERS",
+  ROLES: "ROLES",
+  GLOBAL_ROLES: "GLOBAL_ROLES",
+} as const;

package/src/hooks/query/useAppVersionApi.ts

@@ -0,0 +1,12 @@
+import { useQuery } from "@tanstack/react-query";
+
+import { queryKeys } from "./queryKeys";
+
+import appVersionApi from "../../api/app_version";
+
+export const useFetchAppVersionApi = () =>
+  useQuery({
+    queryKey: [queryKeys.APP_VERSION],
+    queryFn: appVersionApi.fetch,
+    select: ({ data }) => data,
+  });

package/src/hooks/query/useAuth.ts

@@ -0,0 +1,253 @@
+import { useRef } from "react";
+
+import { Alert, Toast } from "@bigbinary/neetoui-rn";
+import { GoogleSignin } from "@react-native-google-signin/google-signin";
+import { useNavigation, type NavigationProp } from "@react-navigation/native";
+import { useMutation } from "@tanstack/react-query";
+import { type AxiosError } from "axios";
+import { useDispatch } from "react-redux";
+
+import {
+  generateOTPAPI,
+  loginWithAppleAPI,
+  loginWithGoogleAPI,
+  fetchOrganizationDetailsAPI,
+  verifyOTPAPI,
+} from "../../api/auth";
+import { type ApiErrorData, getErrorMessage } from "../../config/axios";
+import { isNetworkError } from "../../config/axios/networkErrorHandler";
+import { bugsnagErrorHandler } from "../../config/bugsnag";
+import { useLocalization } from "../../contexts/localization";
+import { setItem } from "../../helpers/asyncStore";
+import { setSecureValue, removeSecureValue } from "../../helpers/keychain";
+import { SCREEN_NAMES } from "../../navigation/screenNames";
+import { type CommonsParamList } from "../../navigation/types";
+import { MAX_RETRY_ATTEMPTS } from "../../screens/authentication/constants";
+import {
+  loginUserAction,
+  setOrganizations,
+  type Organization,
+} from "../../slices/auth";
+
+export const useAuth = () => {
+  const dispatch = useDispatch();
+  const { strings } = useLocalization();
+  const navigation = useNavigation<NavigationProp<CommonsParamList>>();
+  const last504ReportTimeRef = useRef<number | null>(null);
+
+  const selectOrganization = async ({
+    organization,
+  }: {
+    organization: Organization;
+  }) => {
+    const {
+      auth_token,
+      email,
+      subdomain,
+      name,
+      id,
+      organization_name,
+      profile_image_url,
+    } = organization;
+
+    const userAuth = {
+      authToken: auth_token,
+      email,
+    };
+
+    await setItem("email", email);
+    await setSecureValue("userAuth", JSON.stringify(userAuth));
+
+    dispatch(
+      loginUserAction({
+        name,
+        email,
+        id,
+        subdomain,
+        organization_name,
+        profile_image_url,
+      })
+    );
+  };
+
+  const login = async ({
+    organizations,
+  }: {
+    organizations: Organization[];
+  }) => {
+    if (organizations.length > 0) {
+      dispatch(setOrganizations({ organizations }));
+      if (organizations.length > 1) {
+        navigation.navigate(SCREEN_NAMES.SubDomain, {
+          organizations,
+        });
+      } else {
+        await selectOrganization({ organization: organizations[0] });
+      }
+    } else {
+      const signedInUsingGoogle = GoogleSignin.hasPreviousSignIn();
+
+      if (signedInUsingGoogle) {
+        await GoogleSignin.signOut();
+      }
+
+      await removeSecureValue("userAuth");
+
+      Alert.show({
+        title: strings.commons.alertMessage.noWorkspaceFoundTitle,
+        description: strings.commons.alertMessage.noWorkspaceFoundMessage,
+        isCancelable: false,
+      });
+    }
+  };
+
+  const verifyOTPWithRetry = async (params: {
+    code: string;
+    userId: string;
+  }) => {
+    let attempt = 0;
+    let lastError: unknown = null;
+    let delay = 1000;
+
+    while (attempt < MAX_RETRY_ATTEMPTS) {
+      try {
+        return await verifyOTPAPI(params);
+      } catch (error) {
+        const status = (error as AxiosError)?.response?.status;
+
+        if (status === 504) {
+          attempt++;
+          if (attempt < MAX_RETRY_ATTEMPTS) {
+            await new Promise(resolve => setTimeout(resolve, delay));
+            delay *= 2;
+            continue;
+          }
+        }
+
+        lastError = error;
+        break;
+      }
+    }
+
+    throw lastError;
+  };
+
+  const handleVerifyOTPError = (error: AxiosError<ApiErrorData>) => {
+    const status = error?.response?.status;
+
+    if (status === 504) {
+      Toast.show({
+        type: "error",
+        text2:
+          strings.commons.errors.axios.serverTimeout ||
+          "Server is taking too long to respond. Please try again.",
+      });
+
+      if (
+        !last504ReportTimeRef.current ||
+        Date.now() - last504ReportTimeRef.current > 60000
+      ) {
+        bugsnagErrorHandler(
+          new Error("504 Gateway Timeout on /api/mobile/v1/verify_otp"),
+          "verify_otp_504"
+        );
+        last504ReportTimeRef.current = Date.now();
+      }
+    } else if (isNetworkError(error)) {
+      Toast.show({
+        type: "error",
+        text2:
+          strings.commons.errors.axios.networkError ||
+          "Please check your internet connection and try again",
+      });
+    } else {
+      Toast.show({
+        type: "error",
+        text2: getErrorMessage(error?.response?.data, error),
+      });
+
+      bugsnagErrorHandler(error, "verify_otp_error");
+    }
+  };
+
+  return {
+    selectOrganization,
+    useGenerateOTPMutation: () =>
+      useMutation<
+        string,
+        AxiosError<ApiErrorData>,
+        { email: string; showCodeSentToast?: boolean }
+      >({
+        mutationFn: generateOTPAPI,
+        onSuccess: (userId, { email, showCodeSentToast = false }) => {
+          navigation.navigate(SCREEN_NAMES.OTPVerification, {
+            email,
+            userId,
+          });
+
+          if (showCodeSentToast) {
+            Toast.show({
+              type: "success",
+              text2: strings.commons.verificationScreen.resent,
+            });
+          }
+        },
+      }),
+
+    useVerifyOTPMutation: () =>
+      useMutation({
+        mutationFn: verifyOTPWithRetry,
+        onSuccess: ({ data: { organizations } }) => {
+          login({ organizations });
+        },
+        onError: handleVerifyOTPError,
+      }),
+    useLoginViaGoogleMutation: () =>
+      useMutation({
+        mutationFn: ({ serverAuthCode }: { serverAuthCode: string }) =>
+          loginWithGoogleAPI({ serverAuthCode }),
+        onSuccess: ({ data: { organizations } }) => {
+          login({ organizations });
+        },
+      }),
+
+    useLoginViaAppleMutation: () =>
+      useMutation({
+        mutationFn: ({
+          authorizationCode,
+          identityToken,
+        }: {
+          authorizationCode: string;
+          identityToken: string;
+        }) => loginWithAppleAPI({ authorizationCode, identityToken }),
+        onSuccess: ({ data: { organizations } }) => {
+          login({ organizations });
+        },
+      }),
+
+    useSelectOrganizationMutation: () =>
+      useMutation({
+        mutationFn: async ({
+          organization,
+        }: {
+          organization: Organization;
+        }) => {
+          const { subdomain } = organization;
+          const { data } = await fetchOrganizationDetailsAPI({ subdomain });
+
+          // PATCH: For the apps which does not support organization details API updates
+          // is_onboard will be set to true
+          const is_onboard = data?.organization?.is_onboard ?? true;
+
+          if (is_onboard) {
+            await selectOrganization({ organization });
+          } else {
+            navigation.navigate(SCREEN_NAMES.UnBoarded, {
+              name: organization.organization_name,
+              subdomain: organization.subdomain,
+            });
+          }
+        },
+      }),
+  };
+};

package/src/hooks/query/useNotification.ts

@@ -0,0 +1,130 @@
+import { useEffect, useRef } from "react";
+
+import {
+  useMutation,
+  useInfiniteQuery,
+  useQueryClient,
+} from "@tanstack/react-query";
+import notifee from "react-native-notify-kit";
+
+import { queryKeys } from "./queryKeys";
+
+import {
+  registerDeviceTokenAPI,
+  markReadUnReadNotificationAPI,
+  deleteDeviceTokenAPI,
+  fetchNotificationsAPI,
+  markAllNotificationsReadAPI,
+} from "../../api/notifications";
+import { bugsnagErrorHandler } from "../../config/bugsnag";
+import { STORAGE_KEYS, DEFAULT_PAGE_SIZE } from "../../constants";
+import { removeItem, setItem } from "../../helpers/asyncStore";
+import { removeSecureValue } from "../../helpers/keychain";
+import { logoutUserAction } from "../../slices/auth";
+import { useAppDispatch } from "../../store/hooks";
+
+export const useNotification = () => {
+  const dispatch = useAppDispatch();
+  const queryClient = useQueryClient();
+
+  return {
+    useRegisterTokenMutation: () =>
+      useMutation({
+        mutationFn: registerDeviceTokenAPI,
+        onSuccess: (_, response) => {
+          setItem(STORAGE_KEYS.DEVICE_TOKEN, response.device.device_token);
+        },
+        onError: error => {
+          bugsnagErrorHandler(JSON.stringify(error), "notification");
+        },
+      }),
+    useFetchNotifications: () => {
+      const prevBadgeRef = useRef<number | null>(null);
+
+      const query = useInfiniteQuery({
+        queryKey: [queryKeys.NOTIFICATIONS],
+        queryFn: ({ pageParam }) =>
+          fetchNotificationsAPI({
+            page: pageParam,
+          }),
+        initialPageParam: 1,
+        getNextPageParam: (lastPage, pages) => {
+          const currPage = pages.length;
+
+          if (!lastPage?.data?.notifications) {
+            return undefined;
+          }
+
+          const totalNotifications = lastPage.data.total_count;
+          const fetchedNotificationsCount =
+            (currPage - 1) * DEFAULT_PAGE_SIZE +
+            lastPage.data.notifications.length;
+
+          const hasNextPage = fetchedNotificationsCount < totalNotifications;
+
+          return hasNextPage ? currPage + 1 : undefined;
+        },
+        select: data => ({
+          unreadNotifications: data.pages?.[0]?.data?.unread_count || 0,
+          totalNotifications: data.pages?.[0]?.data?.total_count || 0,
+          notifications:
+            data.pages
+              .map(({ data: { notifications } }) => notifications)
+              .flat() || [],
+        }),
+      });
+
+      const unreadCount = query.data?.unreadNotifications ?? 0;
+
+      useEffect(() => {
+        if (prevBadgeRef.current !== unreadCount) {
+          prevBadgeRef.current = unreadCount;
+          notifee.setBadgeCount(unreadCount);
+        }
+      }, [unreadCount]);
+
+      return query;
+    },
+    useMarkReadUnreadNotification: () =>
+      useMutation({
+        // The result is returned, not fired and forgotten, so onSuccess runs
+        // after the server confirms rather than racing the request.
+        mutationFn: ({
+          notificationId,
+          readAt,
+        }: {
+          notificationId: string;
+          readAt: string | null;
+        }) => markReadUnReadNotificationAPI({ notificationId, readAt }),
+        onSuccess: async () => {
+          queryClient.invalidateQueries({
+            queryKey: [queryKeys.NOTIFICATIONS],
+          });
+
+          // Was a silent no-op on Android before — getApplicationIconBadgeNumber
+          // had no Android implementation. Works on both platforms now.
+          const count = await notifee.getBadgeCount();
+          await notifee.setBadgeCount(Math.max(0, count - 1));
+        },
+      }),
+    useDeleteTokenMutation: () =>
+      useMutation({
+        mutationFn: (notificationDeviceId: string) =>
+          deleteDeviceTokenAPI({ notificationDeviceId }),
+        onSettled: async () => {
+          removeItem(STORAGE_KEYS.DEVICE_TOKEN);
+          dispatch(logoutUserAction());
+          await removeSecureValue("userAuth");
+        },
+      }),
+    useMarkAllReadNotification: () =>
+      useMutation({
+        mutationFn: markAllNotificationsReadAPI,
+        onSuccess: () => {
+          queryClient.invalidateQueries({
+            queryKey: [queryKeys.NOTIFICATIONS],
+          });
+        },
+      }),
+  };
+};

package/src/hooks/query/useProfile.ts

@@ -0,0 +1,21 @@
+import { useQuery } from "@tanstack/react-query";
+
+import { queryKeys } from "./queryKeys";
+
+import { getProfileApi } from "../../api/profile";
+import { useAppSelector } from "../../store/hooks";
+
+export const useFetchProfileDetails = (options = {}) => {
+  const isLoggedIn = useAppSelector(store => store.auth.isLoggedIn);
+
+  return useQuery({
+    queryKey: [queryKeys.PROFILE],
+    queryFn: () => getProfileApi(),
+    select: ({ data }) => ({
+      ...data?.user,
+      permissionNames: data?.user?.permissions?.map(p => p.name) ?? [],
+    }),
+    enabled: isLoggedIn,
+    ...options,
+  });
+};

package/src/hooks/query/useRolesApi.ts

@@ -0,0 +1,25 @@
+import { useQuery } from "@tanstack/react-query";
+import { groupBy, prop, reverse } from "ramda";
+
+import { queryKeys } from "./queryKeys";
+
+import globalRolesApi from "../../api/global_roles";
+import organizationRolesApi from "../../api/organization_roles";
+
+const useFetchRoles = (options = {}) =>
+  useQuery({
+    queryKey: [queryKeys.ROLES],
+    queryFn: organizationRolesApi.fetch,
+    select: response => reverse(response?.data?.organization_roles ?? []),
+    ...options,
+  });
+
+const useFetchGlobalRoles = (options = {}) =>
+  useQuery({
+    queryKey: [queryKeys.GLOBAL_ROLES],
+    queryFn: globalRolesApi.fetch,
+    select: response => groupBy(prop("app_name"), response?.data ?? []),
+    ...options,
+  });
+
+export { useFetchRoles, useFetchGlobalRoles };

package/src/hooks/query/useTeamMembersApi.ts

@@ -0,0 +1,109 @@
+import {
+  useInfiniteQuery,
+  useMutation,
+  useQueryClient,
+} from "@tanstack/react-query";
+
+import { queryKeys } from "./queryKeys";
+
+import teamMembersApi from "../../api/team_members";
+import { DEFAULT_PAGE_SIZE } from "../../constants";
+import { logoutUserAction } from "../../slices/auth";
+import { useAppDispatch, useAppSelector } from "../../store/hooks";
+
+const getSearchParams = (searchTerm: string) => [
+  {
+    conditions: [
+      {
+        type: "text",
+        rule: "contains",
+        node: "first_name,last_name,email",
+        value: searchTerm,
+      },
+    ],
+  },
+];
+
+const useFetchTeamMembers = (searchTerm = "") =>
+  useInfiniteQuery({
+    queryKey: [queryKeys.TEAM_MEMBERS, searchTerm],
+    queryFn: ({ pageParam }) => {
+      const params: Record<string, unknown> = {
+        page: pageParam,
+        page_size: DEFAULT_PAGE_SIZE,
+      };
+
+      if (searchTerm) {
+        params.neeto_filters = getSearchParams(searchTerm);
+      }
+
+      return teamMembersApi.fetch(params);
+    },
+    initialPageParam: 1,
+    getNextPageParam: (lastPage, pages) => {
+      const currPage = pages?.length ?? 0;
+      const totalMembers = lastPage?.data?.members_count ?? 0;
+      const fetchedMembersCount =
+        (currPage - 1) * DEFAULT_PAGE_SIZE +
+        (lastPage?.data?.members?.length ?? 0);
+
+      return fetchedMembersCount >= totalMembers ? undefined : currPage + 1;
+    },
+    select: data => data.pages.flatMap(({ data: { members = [] } }) => members),
+  });
+
+interface MutationCallbacks {
+  onSuccess?: () => void;
+}
+
+type TeamMemberPayload = Record<string, unknown>;
+
+const useCreateMember = ({ onSuccess }: MutationCallbacks) => {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({ payload }: { payload: TeamMemberPayload }) =>
+      teamMembersApi.create(payload),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: [queryKeys.TEAM_MEMBERS] });
+      onSuccess?.();
+    },
+  });
+};
+
+const useUpdateTeamMember = ({ onSuccess }: MutationCallbacks) => {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({ id, payload }: { id: string; payload: TeamMemberPayload }) =>
+      teamMembersApi.update(id, { ...payload, active: true }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: [queryKeys.TEAM_MEMBERS] });
+      onSuccess?.();
+    },
+  });
+};
+
+const useRemoveTeamMember = () => {
+  const queryClient = useQueryClient();
+  const userId = useAppSelector(store => store.auth?.userId || "");
+  const dispatch = useAppDispatch();
+
+  return useMutation({
+    mutationFn: ({ id }: { id: string }) =>
+      teamMembersApi.update(id, { is_active: false }),
+    onSuccess: (_, { id }) => {
+      queryClient.invalidateQueries({ queryKey: [queryKeys.TEAM_MEMBERS] });
+      if (id === userId) {
+        dispatch(logoutUserAction());
+      }
+    },
+  });
+};
+
+export {
+  useFetchTeamMembers,
+  useCreateMember,
+  useUpdateTeamMember,
+  useRemoveTeamMember,
+};

package/src/hooks/useAppState.ts

@@ -0,0 +1,16 @@
+import { useEffect, useState } from "react";
+import { AppState } from "react-native";
+
+export const useAppState = () => {
+  const [appState, setAppState] = useState(AppState.currentState);
+
+  useEffect(() => {
+    const changeListener = AppState.addEventListener("change", setAppState);
+
+    return () => {
+      changeListener.remove();
+    };
+  }, []);
+
+  return appState;
+};